diff --git a/CMakeLists.txt b/CMakeLists.txt index f7a29aca8..f40039a3a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -72,7 +72,7 @@ if(Vulkan_FOUND) message(STATUS "Couldn't find slang Shader Compiler executable, make sure it is present in Vulkan SDK or add it manually via Vulkan_slang_EXECUTABLE cmake variable. Slang shaders won't be compiled.") endif() # glsl compiler - if(NOT Vulkan_glslang_exe_FOUND) + if(NOT Vulkan_glslc_exe_FOUND) find_program(Vulkan_glslc_EXECUTABLE NAMES glslc HINTS @@ -85,7 +85,21 @@ if(Vulkan_FOUND) else() message(STATUS "Couldn't find glslc Shader Compiler executable, make sure it is present in Vulkan SDK or add it manually via Vulkan_glslc_EXECUTABLE cmake variable. GLSL shaders won't be compiled.") endif() - # glsl compiler + # spvasm compiler + if(NOT Vulkan_spirvas_exe_FOUND) + find_program(Vulkan_spirvas_EXECUTABLE + NAMES spirv-as + HINTS + "$ENV{VULKAN_SDK}/Bin" + "$ENV{VULKAN_SDK}/bin" + ) + endif() + if(Vulkan_spirvas_EXECUTABLE) + message(STATUS "Found spirv-as Shader Compiler under ${Vulkan_spirvas_EXECUTABLE}") + else() + message(STATUS "Couldn't find spirv-as Shader Compiler executable, make sure it is present in Vulkan SDK or add it manually via Vulkan_spirvas_EXECUTABLE cmake variable. SPIR-V assembly shaders won't be compiled.") + endif() + endif() # globally add VKB_DEBUG for the debug build diff --git a/antora/CMakeLists.txt b/antora/CMakeLists.txt index 8f88721a6..93d9214e1 100644 --- a/antora/CMakeLists.txt +++ b/antora/CMakeLists.txt @@ -1,4 +1,4 @@ -# Copyright 2022-2024 The Khronos Group Inc. +# Copyright 2022-2025 The Khronos Group Inc. # SPDX-License-Identifier: Apache-2.0 # Configure Vulkan Guide Antora tree with transformed markup files. @@ -19,10 +19,10 @@ function(gatherAntoraAssets) set(IMAGES_DIR_SEARCH) foreach (DIR ${DIRS_TO_SEARCH}) list(APPEND PAGES_DIR_SEARCH ${CMAKE_SOURCE_DIR}/${DIR}/*.adoc) - list(APPEND IMAGES_DIR_SEARCH ${CMAKE_SOURCE_DIR}/${DIR}/*.jpg ${CMAKE_SOURCE_DIR}/${DIR}/*.png ${CMAKE_SOURCE_DIR}/${DIR}/*.gif) + list(APPEND IMAGES_DIR_SEARCH ${CMAKE_SOURCE_DIR}/${DIR}/*.jpg ${CMAKE_SOURCE_DIR}/${DIR}/*.png ${CMAKE_SOURCE_DIR}/${DIR}/*.gif ${CMAKE_SOURCE_DIR}/*.svg) endforeach () file(GLOB PAGES ${CMAKE_SOURCE_DIR}/*.adoc) - file(GLOB IMAGES ${CMAKE_SOURCE_DIR}/*.jpg ${CMAKE_SOURCE_DIR}/*.png ${CMAKE_SOURCE_DIR}/*.gif) + file(GLOB IMAGES ${CMAKE_SOURCE_DIR}/*.jpg ${CMAKE_SOURCE_DIR}/*.png ${CMAKE_SOURCE_DIR}/*.gif ${CMAKE_SOURCE_DIR}/*.svg) file(GLOB_RECURSE PAGES_R ${PAGES_DIR_SEARCH}) file(GLOB_RECURSE IMAGES_R ${IMAGES_DIR_SEARCH}) diff --git a/antora/modules/ROOT/nav.adoc b/antora/modules/ROOT/nav.adoc index cc1aec5f1..fd04e38dc 100644 --- a/antora/modules/ROOT/nav.adoc +++ b/antora/modules/ROOT/nav.adoc @@ -1,6 +1,7 @@ //// - Copyright (c) 2023-2025, Holochip Inc - Copyright (c) 2023-2025, Sascha Willems +- Copyright (c) 2025, Arm Limited and Contributors - - SPDX-License-Identifier: Apache-2.0 - @@ -89,6 +90,8 @@ ** xref:samples/extensions/shader_debugprintf/README.adoc[Shader Debug Printf] ** xref:samples/extensions/sparse_image/README.adoc[Sparse Image] ** xref:samples/extensions/synchronization_2/README.adoc[Synchronization 2] +** xref:samples/extensions/tensor_and_data_graph/README.adoc[Tensor and Data Graph] +*** xref:samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/README.adoc[Simple Tensor and Data Graph] ** xref:samples/extensions/timeline_semaphore/README.adoc[Timeline semaphore] ** xref:samples/extensions/vertex_dynamic_state/README.adoc[Vertex dynamic state] ** xref:samples/extensions/dynamic_multisample_rasterization/README.adoc[Dynamic multisample rasterization] diff --git a/bldsys/cmake/sample_helper.cmake b/bldsys/cmake/sample_helper.cmake index 43387dea0..18b5d9215 100644 --- a/bldsys/cmake/sample_helper.cmake +++ b/bldsys/cmake/sample_helper.cmake @@ -22,7 +22,7 @@ set(SCRIPT_DIR ${CMAKE_CURRENT_LIST_DIR}) function(add_sample) - set(options) + set(options) set(oneValueArgs ID CATEGORY AUTHOR NAME DESCRIPTION DXC_ADDITIONAL_ARGUMENTS GLSLC_ADDITIONAL_ARGUMENTS) set(multiValueArgs FILES LIBS SHADER_FILES_GLSL SHADER_FILES_HLSL SHADER_FILES_SLANG) @@ -35,7 +35,7 @@ function(add_sample) AUTHOR ${TARGET_AUTHOR} NAME ${TARGET_NAME} DESCRIPTION ${TARGET_DESCRIPTION} - TAGS + TAGS "any" FILES ${TARGET_FILES} @@ -54,7 +54,7 @@ endfunction() function(add_sample_with_tags) set(options) set(oneValueArgs ID CATEGORY AUTHOR NAME DESCRIPTION DXC_ADDITIONAL_ARGUMENTS GLSLC_ADDITIONAL_ARGUMENTS) - set(multiValueArgs TAGS FILES LIBS SHADER_FILES_GLSL SHADER_FILES_HLSL SHADER_FILES_SLANG) + set(multiValueArgs TAGS FILES LIBS SHADER_FILES_GLSL SHADER_FILES_HLSL SHADER_FILES_SLANG SHADER_FILES_SPVASM) cmake_parse_arguments(TARGET "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) @@ -83,7 +83,12 @@ function(add_sample_with_tags) # Add slang shader files for this sample foreach(SHADER_FILE_SLANG ${TARGET_SHADER_FILES_SLANG}) list(APPEND SHADERS_SLANG "${PROJECT_SOURCE_DIR}/shaders/${SHADER_FILE_SLANG}") - endforeach() + endforeach() + + # Add spvasm shader files for this sample + foreach(SHADER_FILE_SPVASM ${TARGET_SHADER_FILES_SPVASM}) + list(APPEND SHADERS_SPVASM "${PROJECT_SOURCE_DIR}/shaders/${SHADER_FILE_SPVASM}") + endforeach() add_project( TYPE "Sample" @@ -92,7 +97,7 @@ function(add_sample_with_tags) AUTHOR ${TARGET_AUTHOR} NAME ${TARGET_NAME} DESCRIPTION ${TARGET_DESCRIPTION} - TAGS + TAGS ${TARGET_TAGS} FILES ${SRC_FILES} @@ -103,15 +108,17 @@ function(add_sample_with_tags) SHADERS_HLSL ${SHADERS_HLSL} SHADERS_SLANG - ${SHADERS_SLANG} + ${SHADERS_SLANG} + SHADERS_SPVASM + ${SHADERS_SPVASM} DXC_ADDITIONAL_ARGUMENTS ${TARGET_DXC_ADDITIONAL_ARGUMENTS} GLSLC_ADDITIONAL_ARGUMENTS ${TARGET_GLSLC_ADDITIONAL_ARGUMENTS}) endfunction() function(add_project) - set(options) + set(options) set(oneValueArgs TYPE ID CATEGORY AUTHOR NAME DESCRIPTION DXC_ADDITIONAL_ARGUMENTS GLSLC_ADDITIONAL_ARGUMENTS) - set(multiValueArgs TAGS FILES LIBS SHADERS_GLSL SHADERS_HLSL SHADERS_SLANG) + set(multiValueArgs TAGS FILES LIBS SHADERS_GLSL SHADERS_HLSL SHADERS_SLANG SHADERS_SPVASM) cmake_parse_arguments(TARGET "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) @@ -138,16 +145,19 @@ function(add_project) if (TARGET_SHADERS_HLSL) source_group("\\Shaders\\hlsl" FILES ${TARGET_SHADERS_HLSL}) # Disable automatic compilation of HLSL shaders for MSVC - set_source_files_properties(SOURCE ${SHADERS_HLSL} PROPERTIES VS_SETTINGS "ExcludedFromBuild=true") + set_source_files_properties(SOURCE ${SHADERS_HLSL} PROPERTIES VS_SETTINGS "ExcludedFromBuild=true") endif() if (TARGET_SHADERS_SLANG) source_group("\\Shaders\\slang" FILES ${TARGET_SHADERS_SLANG}) - endif() + endif() + if (TARGET_SHADERS_SPVASM) + source_group("\\Shaders\\spvasm" FILES ${TARGET_SHADERS_SPVASM}) + endif() if(${TARGET_TYPE} STREQUAL "Sample") - add_library(${PROJECT_NAME} OBJECT ${TARGET_FILES} ${SHADERS_GLSL} ${SHADERS_HLSL} ${SHADERS_SLANG}) + add_library(${PROJECT_NAME} OBJECT ${TARGET_FILES} ${SHADERS_GLSL} ${SHADERS_HLSL} ${SHADERS_SLANG} ${SHADERS_SPVASM}) elseif(${TARGET_TYPE} STREQUAL "Test") - add_library(${PROJECT_NAME} STATIC ${TARGET_FILES} ${SHADERS_GLSL} ${SHADERS_HLSL} ${SHADERS_SLANG}) + add_library(${PROJECT_NAME} STATIC ${TARGET_FILES} ${SHADERS_GLSL} ${SHADERS_HLSL} ${SHADERS_SLANG} ${SHADERS_SPVASM}) endif() set_target_properties(${PROJECT_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON) @@ -160,7 +170,7 @@ endif() target_link_libraries(${PROJECT_NAME} PUBLIC ${TARGET_LIBS}) endif() - # capitalise the first letter of the category (performance -> Performance) + # capitalise the first letter of the category (performance -> Performance) string(SUBSTRING ${TARGET_CATEGORY} 0 1 FIRST_LETTER) string(TOUPPER ${FIRST_LETTER} FIRST_LETTER) string(REGEX REPLACE "^.(.*)" "${FIRST_LETTER}\\1" CATEGORY "${TARGET_CATEGORY}") @@ -168,7 +178,7 @@ endif() if(${TARGET_TYPE} STREQUAL "Sample") # set sample properties set_target_properties(${PROJECT_NAME} - PROPERTIES + PROPERTIES SAMPLE_CATEGORY ${TARGET_CATEGORY} SAMPLE_AUTHOR ${TARGET_AUTHOR} SAMPLE_NAME ${TARGET_NAME} @@ -185,12 +195,12 @@ endif() if(VKB_DO_CLANG_TIDY) set_target_properties(${PROJECT_NAME} PROPERTIES CXX_CLANG_TIDY "${VKB_DO_CLANG_TIDY}") endif() - + # HLSL compilation via DXC if(Vulkan_dxc_EXECUTABLE AND DEFINED SHADERS_HLSL) set(OUTPUT_FILES "") set(HLSL_TARGET_NAME ${PROJECT_NAME}-HLSL) - foreach(SHADER_FILE_HLSL ${TARGET_SHADERS_HLSL}) + foreach(SHADER_FILE_HLSL ${TARGET_SHADERS_HLSL}) get_filename_component(HLSL_SPV_FILE ${SHADER_FILE_HLSL} NAME_WLE) get_filename_component(bare_name ${HLSL_SPV_FILE} NAME_WLE) get_filename_component(extension ${HLSL_SPV_FILE} LAST_EXT) @@ -242,7 +252,7 @@ endif() endforeach() add_custom_target(${HLSL_TARGET_NAME} DEPENDS ${OUTPUT_FILES}) set_property(TARGET ${HLSL_TARGET_NAME} PROPERTY FOLDER "Shaders-HLSL") - add_dependencies(${PROJECT_NAME} ${HLSL_TARGET_NAME}) + add_dependencies(${PROJECT_NAME} ${HLSL_TARGET_NAME}) endif() # Slang shader compilation @@ -274,11 +284,11 @@ endif() endforeach() add_custom_target(${SLANG_TARGET_NAME} DEPENDS ${OUTPUT_FILES}) set_property(TARGET ${SLANG_TARGET_NAME} PROPERTY FOLDER "Shaders-SLANG") - add_dependencies(${PROJECT_NAME} ${SLANG_TARGET_NAME}) + add_dependencies(${PROJECT_NAME} ${SLANG_TARGET_NAME}) endif() # GLSL shader compilation - if(Vulkan_glslc_EXECUTABLE AND DEFINED SHADERS_GLSL) + if(Vulkan_glslc_EXECUTABLE AND DEFINED SHADERS_GLSL) set(GLSL_TARGET_NAME ${PROJECT_NAME}-GLSL) set(OUTPUT_FILES "") foreach(SHADER_FILE_GLSL ${TARGET_SHADERS_GLSL}) @@ -293,9 +303,22 @@ endif() set(OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/shader-glsl-spv") set(OUTPUT_FILE ${OUTPUT_DIR}/${bare_name}${extension}.spv) file(MAKE_DIRECTORY ${OUTPUT_DIR}) + + # NOTE: Vulkan SDK has old glslc but new glslang. We must use glslang to compile shaders from `tensor_and_data_graph`. + # TODO: Remove workaround once glslc is updated. + if ("${CMAKE_CURRENT_BINARY_DIR}" MATCHES "tensor_and_data_graph" AND NOT ${SHADER_FILE_GLSL} MATCHES "base") + # glslang (NOT glslangValidator, as that also seems to be old) + string(REPLACE "glslangValidator" "glslang" GLSLANG_EXECUTABLE ${Vulkan_GLSLANG_VALIDATOR_EXECUTABLE}) + SET(COMPILE_COMMAND ${GLSLANG_EXECUTABLE} ${SHADER_FILE_GLSL} -o ${OUTPUT_FILE} -V -I"${CMAKE_SOURCE_DIR}/shaders/includes/glsl" ${TARGET_GLSLC_ADDITIONAL_ARGUMENTS}) + else() + # glslc + SET(COMPILE_COMMAND ${Vulkan_glslc_EXECUTABLE} ${SHADER_FILE_GLSL} -o ${OUTPUT_FILE} -I "${CMAKE_SOURCE_DIR}/shaders/includes/glsl" ${TARGET_GLSLC_ADDITIONAL_ARGUMENTS}) + endif() + + add_custom_command( OUTPUT ${OUTPUT_FILE} - COMMAND ${Vulkan_glslc_EXECUTABLE} ${SHADER_FILE_GLSL} -o ${OUTPUT_FILE} -I "${CMAKE_SOURCE_DIR}/shaders/includes/glsl" ${TARGET_GLSLC_ADDITIONAL_ARGUMENTS} + COMMAND ${COMPILE_COMMAND} COMMAND ${CMAKE_COMMAND} -E copy ${OUTPUT_FILE} ${directory} MAIN_DEPENDENCY ${SHADER_FILE_GLSL} WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} @@ -310,4 +333,34 @@ endif() add_dependencies(${PROJECT_NAME} ${GLSL_TARGET_NAME}) endif() + # spvasm shader compilation + if(Vulkan_spirvas_EXECUTABLE AND DEFINED SHADERS_SPVASM) + set(SPVASM_TARGET_NAME ${PROJECT_NAME}-SPVASM) + set(OUTPUT_FILES "") + foreach(SHADER_FILE_SPVASM ${TARGET_SHADERS_SPVASM}) + get_filename_component(SPVASM_FILE ${SHADER_FILE_SPVASM} NAME_WLE) + get_filename_component(bare_name ${SPVASM_FILE} NAME_WLE) + get_filename_component(extension ${SHADER_FILE_SPVASM} LAST_EXT) + get_filename_component(directory ${SHADER_FILE_SPVASM} DIRECTORY) + set(OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/shader-spvasm-spv") + set(OUTPUT_FILE ${OUTPUT_DIR}/${bare_name}${extension}.spv) + file(MAKE_DIRECTORY ${OUTPUT_DIR}) + add_custom_command( + OUTPUT ${OUTPUT_FILE} + COMMAND ${Vulkan_spirvas_EXECUTABLE} ${SHADER_FILE_SPVASM} -o ${OUTPUT_FILE} ${TARGET_SPVASM_ADDITIONAL_ARGUMENTS} + COMMAND ${CMAKE_COMMAND} -E copy ${OUTPUT_FILE} ${directory} + MAIN_DEPENDENCY ${SHADER_FILE_SPVASM} + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} + ) + list(APPEND OUTPUT_FILES ${OUTPUT_FILE}) + set_source_files_properties(${OUTPUT_FILE} PROPERTIES + MACOSX_PACKAGE_LOCATION Resources + ) + endforeach() + add_custom_target(${SPVASM_TARGET_NAME} DEPENDS ${OUTPUT_FILES}) + set_property(TARGET ${SPVASM_TARGET_NAME} PROPERTY FOLDER "Shaders-SPVASM") + add_dependencies(${PROJECT_NAME} ${SPVASM_TARGET_NAME}) + + endif() + endfunction() \ No newline at end of file diff --git a/docs/build.adoc b/docs/build.adoc index 5b8d16429..46f3aa5ba 100644 --- a/docs/build.adoc +++ b/docs/build.adoc @@ -210,10 +210,10 @@ Alternatively, for command line builds use the steps below: cmake --build build/windows --config Release --target vulkan_samples ---- -`Step 3.` Run the *Vulkan Samples* application +`Step 3.` Run the *Vulkan Samples* application by specifying the name of the sample ---- -build\windows\app\bin\Release\AMD64\vulkan_samples.exe +build\windows\app\bin\Release\AMD64\vulkan_samples.exe sample ---- == Linux @@ -388,7 +388,7 @@ ____ It is highly recommended to install https://d.android.com/studio[Android Studio] to build, run and trace the sample project. Building via Android Studio requires at least Ladybug 2024.2.1. Android Studio uses the following plugins/tools to build samples: - + * Android Gradle Plugin * CMake Plugin, which installs and uses Ninja * NDK diff --git a/framework/common/vk_common.cpp b/framework/common/vk_common.cpp index 5fada1103..5814a3f96 100644 --- a/framework/common/vk_common.cpp +++ b/framework/common/vk_common.cpp @@ -334,6 +334,12 @@ int32_t get_bits_per_pixel(VkFormat format) VkShaderModule load_shader(const std::string &filename, VkDevice device, VkShaderStageFlagBits stage) { auto spirv = vkb::fs::read_shader_binary_u32(filename); + return load_shader_from_vector(spirv, device); +} + +VkShaderModule load_shader_from_vector(const std::vector &spirv, VkDevice device) +{ + assert(spirv.size() != 0); VkShaderModule shader_module; VkShaderModuleCreateInfo module_create_info{}; diff --git a/framework/common/vk_common.h b/framework/common/vk_common.h index 6192fbe89..10fe0df2c 100644 --- a/framework/common/vk_common.h +++ b/framework/common/vk_common.h @@ -145,6 +145,14 @@ enum class ShadingLanguage */ VkShaderModule load_shader(const std::string &filename, VkDevice device, VkShaderStageFlagBits stage); +/** + * @brief Helper function to create a VkShaderModule from a SPIR-V vector + * @param spirv The SPIR-V code in vector format + * @param device The logical device + * @return The shader module containing the loaded shader + */ +VkShaderModule load_shader_from_vector(const std::vector &spirv, VkDevice device); + /** * @brief Helper function to select a VkSurfaceFormatKHR * @param gpu The VkPhysicalDevice to select a format for. diff --git a/framework/core/allocated.h b/framework/core/allocated.h index e62ce9cd0..aba460ebe 100644 --- a/framework/core/allocated.h +++ b/framework/core/allocated.h @@ -1,5 +1,6 @@ /* Copyright (c) 2021-2025, NVIDIA CORPORATION. All rights reserved. * Copyright (c) 2024-2025, Bradley Austin Davis. All rights reserved. + * Copyright (c) 2025, Arm Limited and Contributors * * SPDX-License-Identifier: Apache-2.0 * @@ -181,6 +182,11 @@ class Allocated : public vkb::core::VulkanResource */ DeviceMemoryType get_memory() const; + /** + * @brief Retrieves the offset into the raw Vulkan memory object (which can be retrieved from get_memory()). + */ + DeviceSizeType get_memory_offset() const; + /** * @brief Maps Vulkan memory if it isn't already mapped to a host visible address. Does nothing if the * allocation is already mapped (including persistently mapped allocations). @@ -309,6 +315,25 @@ class Allocated : public vkb::core::VulkanResource * instead of `protected`, and because it (mostly) isolates interaction with the VMA to a single class */ [[nodiscard]] ImageType create_image(ImageCreateInfoType const &create_info); + + /** + * @brief Internal method to retrieve the VMA allocation owned by this object. + * + * This is needed for derived classes to handle some of the VMA allocation code themselves, + * in particular for Tensor objects to be allocated, in tensor_and_data_graph_common.cpp. + * Once Tensor objects are integrated into VMA, this code can be refactored and this function removed. + */ + VmaAllocation get_allocation() const; + + /** + * @brief Internal method to set the VMA allocation owned by this object. + * + * This is needed for derived classes to handle some of the VMA allocation code themselves, + * in particular for Tensor objects to be allocated, in tensor_and_data_graph_common.cpp. + * Once Tensor objects are integrated into VMA, this code can be refactored and this function removed. + */ + void set_allocation(VmaAllocation alloc); + /** * @brief The post_create method is called after the creation of a buffer or image to store the allocation info internally. Derived classes * could in theory override this to ensure any post-allocation operations are performed, but the base class should always be called to ensure @@ -563,6 +588,21 @@ inline typename Allocated::DeviceMemoryType Allocated +inline typename Allocated::DeviceSizeType Allocated::get_memory_offset() const +{ + VmaAllocationInfo alloc_info; + vmaGetAllocationInfo(get_memory_allocator(), allocation, &alloc_info); + if constexpr (bindingType == vkb::BindingType::Cpp) + { + return static_cast(alloc_info.offset); + } + else + { + return alloc_info.offset; + } +} + template inline uint8_t *Allocated::map() { @@ -580,6 +620,18 @@ inline bool Allocated::mapped() const return mapped_data != nullptr; } +template +inline VmaAllocation Allocated::get_allocation() const +{ + return allocation; +} + +template +inline void Allocated::set_allocation(VmaAllocation alloc) +{ + allocation = alloc; +} + template inline void Allocated::post_create(VmaAllocationInfo const &allocation_info) { diff --git a/framework/vulkan_sample.h b/framework/vulkan_sample.h index a2c2a04c4..6dda756c7 100644 --- a/framework/vulkan_sample.h +++ b/framework/vulkan_sample.h @@ -79,11 +79,11 @@ namespace vkb * - updating Stats and Gui * - getting an active RenderTarget constructed by the factory function of the RenderFrame * - setting up barriers for color and depth, note that these are only for the default RenderTarget - * - calling VulkanSample::draw_swapchain_renderpass (see below) + * - calling VulkanSample::draw_renderpass (see below) * - setting up a barrier for the Swapchain transition to present * - submitting the CommandBuffer and end the Frame (present) * - * @subsection draw_swapchain Draw swapchain renderpass + * @subsection draw_renderpass Draw renderpass * The function starts and ends a RenderPass which includes setting up viewport, scissors, * blend state (etc.) and calling draw_scene. * Note that RenderPipeline::draw is not virtual in RenderPipeline, but internally it calls @@ -548,8 +548,8 @@ void VulkanSample::create_render_context_impl(const std::vectorget_properties().vsync == Window::Vsync::OFF) ? vk::PresentModeKHR::eMailbox : vk::PresentModeKHR::eFifo; std::vector present_mode_priority_list{vk::PresentModeKHR::eFifo, vk::PresentModeKHR::eMailbox, vk::PresentModeKHR::eImmediate}; #else - vk::PresentModeKHR present_mode = (window->get_properties().vsync == Window::Vsync::ON) ? vk::PresentModeKHR::eFifo : vk::PresentModeKHR::eMailbox; - std::vector present_mode_priority_list{vk::PresentModeKHR::eMailbox, vk::PresentModeKHR::eImmediate, vk::PresentModeKHR::eFifo}; + vk::PresentModeKHR present_mode = (window->get_properties().vsync == Window::Vsync::ON) ? vk::PresentModeKHR::eFifo : vk::PresentModeKHR::eMailbox; + std::vector present_mode_priority_list{vk::PresentModeKHR::eMailbox, vk::PresentModeKHR::eImmediate, vk::PresentModeKHR::eFifo}; #endif render_context = diff --git a/framework/vulkan_type_mapping.h b/framework/vulkan_type_mapping.h index ecd744f68..ffaabdb87 100644 --- a/framework/vulkan_type_mapping.h +++ b/framework/vulkan_type_mapping.h @@ -1,4 +1,5 @@ -/* Copyright (c) 2024-2025, NVIDIA CORPORATION. All rights reserved. +/* Copyright (c) 2025, Arm Limited and Contributors + * Copyright (c) 2024-2025, NVIDIA CORPORATION. All rights reserved. * * SPDX-License-Identifier: Apache-2.0 * @@ -48,6 +49,12 @@ struct HPPType using Type = vk::CommandBuffer; }; +template <> +struct HPPType +{ + using Type = vk::DataGraphPipelineSessionARM; +}; + template <> struct HPPType { @@ -260,6 +267,12 @@ struct HPPType using Type = vk::PhysicalDeviceSynchronization2FeaturesKHR; }; +template <> +struct HPPType +{ + using Type = vk::PhysicalDeviceTensorFeaturesARM; +}; + template <> struct HPPType { @@ -278,12 +291,30 @@ struct HPPType using Type = vk::PhysicalDeviceVulkan12Features; }; +template <> +struct HPPType +{ + using Type = vk::PhysicalDeviceVulkan13Features; +}; + template <> struct HPPType { using Type = vk::PhysicalDevice16BitStorageFeatures; }; +template <> +struct HPPType +{ + using Type = vk::Pipeline; +}; + +template <> +struct HPPType +{ + using Type = vk::PipelineLayout; +}; + template <> struct HPPType { @@ -295,6 +326,24 @@ struct HPPType { using Type = vk::Sampler; }; + +template <> +struct HPPType +{ + using Type = vk::TensorARM; +}; + +template <> +struct HPPType +{ + using Type = vk::TensorCreateInfoARM; +}; + +template <> +struct HPPType +{ + using Type = vk::TensorViewARM; +}; } // namespace detail template @@ -312,4 +361,4 @@ struct VulkanTypeMapping using Type = typename detail::HPPType::Type; }; -} // namespace vkb +} // namespace vkb \ No newline at end of file diff --git a/samples/CMakeLists.txt b/samples/CMakeLists.txt index 5d58f7ea7..0ba7aa663 100644 --- a/samples/CMakeLists.txt +++ b/samples/CMakeLists.txt @@ -92,6 +92,7 @@ set(ORDER_LIST "dynamic_multisample_rasterization" "sparse_image" "dynamic_primitive_clipping" + "simple_tensor_and_data_graph" #Performance Samples "swapchain_images" diff --git a/samples/extensions/README.adoc b/samples/extensions/README.adoc index 18b09ca8b..3c5787f11 100644 --- a/samples/extensions/README.adoc +++ b/samples/extensions/README.adoc @@ -1,5 +1,6 @@ //// -- Copyright (c) 2021-2024, The Khronos Group +- Copyright (c) 2025, Arm Limited and Contributors +- Copyright (c) 2021-2025, The Khronos Group - - SPDX-License-Identifier: Apache-2.0 - @@ -302,3 +303,12 @@ Demonstrate the use of the host image extension to directly copy from a host buf *Extensions:* https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_extended_dynamic_state3.html[`VK_EXT_line_rasterization`], https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_extended_dynamic_state3.html[`VK_EXT_extended_dynamic_state3`] Demonstrate how to use dynamic multisample rasterization (MSAA) + +=== xref:./{extension_samplespath}tensor_and_data_graph/README.adoc[Tensor and Data Graph] + +*Extensions*: https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_ARM_tensors.html[`VK_ARM_tensors`], https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_ARM_data_graph.html[`VK_ARM_data_graph`] + +Demonstrate how to build data graph pipelines and execute neural networks: + +* xref:./{extension_samplespath}tensor_and_data_graph/simple_tensor_and_data_graph/README.adoc[simple_tensor_and_data_graph] +- Explains how to set up and execute a simple neural network using a data graph pipeline. diff --git a/samples/extensions/tensor_and_data_graph/README.adoc b/samples/extensions/tensor_and_data_graph/README.adoc new file mode 100644 index 000000000..149d3075a --- /dev/null +++ b/samples/extensions/tensor_and_data_graph/README.adoc @@ -0,0 +1,69 @@ +//// +- Copyright (c) 2024-2025, Arm Limited and Contributors +- +- SPDX-License-Identifier: Apache-2.0 +- +- 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. +- +//// + += Tensor and Data Graph + +== Overview + +The samples in this folder demonstrate the use of the *VK_ARM_tensors* and *VK_ARM_data_graph* extensions. The *VK_ARM_data_graph* extension introduces data graph pipelines, which are used in all samples. A data graph pipeline is a new Vulkan pipeline type designed to execute dataflow graphs that can be described using SPIR-V modules. Similar to compute pipelines, they use descriptor sets to access external resources, are compiled at creation time, and support pipeline caching and offline binaries. + +Data graph pipelines integrate naturally into the existing Vulkan ecosystem, leveraging familiar SPIR-V tooling and workflows, and are especially well-suited for machine learning workloads as a drop-in replacement for sequences of compute pipelines. + +To demonstrate their use, we’ve added data graph pipeline-based samples that walk through setting up a data graph pipeline and executing simple neural networks. These examples cover key features such as using graph constants, writing SPIR-V code, creating tensors, interacting with compute shaders and aliasing memory to avoid unnecessary copying. + + +The samples in this folder are: + +* xref:./simple_tensor_and_data_graph/README.adoc[Simple tensor and data graph] + +== Setup + +Some setup steps are needed before you can build and run these samples. + +NOTE: The samples and their dependencies can be built and run on Windows and Linux, other operating systems are not currently supported. + +=== Update Vulkan SDK + +In order to compile the shader code used in these samples, a recent version of the Vulkan SDK is required. The samples have been tested and confirmed to work with SDK version 1.4.321. + +=== Enable the emulation layers (Graph & Tensor) + +Note: The ML Emulation Layer for Vulkan is only required on devices where the *VK_ARM_tensors* and *VK_ARM_data_graph* extensions are not available. + +Install and enable link:https://github.com/arm/ai-ml-emulation-layer-for-vulkan[ML Emulation Layer for Vulkan] from GitHub. Please follow the steps in that repository to build and enable the emulation layers. + +Alternatively, on Windows, the Vulkan Configurator tool — which is part of the Vulkan SDK — can also be used, as described below. If it is not already installed, it can be obtained from the link:https://vulkan.lunarg.com/[Vulkan SDK] website. + +Once installed, open Vulkan Configurator and navigate to the Vulkan Layers Location tab. Click the plus (+) symbol to append a user-defined layers path, +and navigate to the folder containing the built layers (DLLs and json files). Please note that there are two separate layers that need to be enabled, so if these are in separate folders then you will need to add both. + +Note: It is recommended to disable the validation layer when running these samples as the new extensions are not supported yet. + +image::./loading_layers.png[Loading Layers Completed] + +This should add the layers to the Vulkan Loader Management tab. The Graph layer needs to sit on top of the Tensor layer. + +image::./verify_layers.png[VK Layers] + +When running any of these samples, if you receive an error message similar to: +---- + Requested required feature is not supported +---- +then it is likely that the emulation layers are not enabled correctly. Please check the steps above to ensure that the layers are loaded and enabled and make sure the Vulkan Configurator is running before launching the sample executable. Depending on your system, you may encounter issues with using the emulation layers when running with administrative privileges - please try running without administrative privileges if you encounter issues. + diff --git a/samples/extensions/tensor_and_data_graph/loading_layers.png b/samples/extensions/tensor_and_data_graph/loading_layers.png new file mode 100644 index 000000000..dfbed90e4 Binary files /dev/null and b/samples/extensions/tensor_and_data_graph/loading_layers.png differ diff --git a/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/CMakeLists.txt b/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/CMakeLists.txt new file mode 100644 index 000000000..a95a895ef --- /dev/null +++ b/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/CMakeLists.txt @@ -0,0 +1,39 @@ +# Copyright (c) 2024-2025, Arm Limited and Contributors +# +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 the "License"; +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +if(WIN32 OR ANDROID OR CMAKE_SYSTEM_NAME STREQUAL "Linux") + add_sample_with_tags( + ID "simple_tensor_and_data_graph" + CATEGORY "extensions/tensor_and_data_graph" + AUTHOR "Arm Ltd." + NAME "Simple tensor and data graph" + DESCRIPTION "Demonstrates simple use of the tensor and data graph extensions for machine learning inference" + TAGS + "arm" + FILES + "../tensor_and_data_graph_common.h" + "../tensor_and_data_graph_common.cpp" + "simple_tensor_and_data_graph.h" + "simple_tensor_and_data_graph.cpp" + SHADER_FILES_GLSL + "tensor_and_data_graph/glsl/blit.frag" + "tensor_and_data_graph/glsl/fullscreen.vert" + "tensor_and_data_graph/glsl/visualization_two_tensors.comp" + SHADER_FILES_SPVASM + "tensor_and_data_graph/simple_tensor_and_data_graph/spirv/pooling.spvasm" + ) +endif() \ No newline at end of file diff --git a/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/README.adoc b/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/README.adoc new file mode 100644 index 000000000..f0697ffcf --- /dev/null +++ b/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/README.adoc @@ -0,0 +1,587 @@ +//// +- Copyright (c) 2024-2025, Arm Limited and Contributors +- +- SPDX-License-Identifier: Apache-2.0 +- +- 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. +- +//// += Simple tensor and data graph + +ifdef::site-gen-antora[] +TIP: The source for this sample can be found in the https://github.com/KhronosGroup/Vulkan-Samples/tree/main/samples/extensions/extensions/tensor_and_data_graph/simple_tensor_and_data_graph[Khronos Vulkan samples github repository]. +endif::[] + +== Overview + +This sample demonstrates the usage of the `VK_ARM_tensors` and `VK_ARM_data_graph` extensions for machine learning inference. These extensions provide a way to define tensor data and construct computation graphs for neural network execution using hardware acceleration. + +This is the first in a series of samples which introduce the tensor and data graph extensions. Please see the parent xref:samples/extensions/tensor_and_data_graph/README.adoc[Tensor and Data Graph] page for the full list of samples. + +NOTE: While the model used in this example is expressed using https://www.mlplatform.org/tosa/[TOSA operations], there is currently no defined way to query for TOSA operation support from the Vulkan API. Execution of this sample may fail on implementations of these extensions that do not include specific support for TOSA operations. + +== Setup + +If you would like to build and run this sample, please make sure to first follow the setup steps on the xref:samples/extensions/tensor_and_data_graph/README.adoc[Tensor and Data Graph] page. + +== Introduction + +This sample demonstrates how to run a minimal neural network that consumes a single input tensor, with a batch size of 1, a width and height of 10 and 3 channels. The input tensor has a fixed pattern of colors uploaded to it from the CPU. In this case we are using a neural network with a single 2D average pooling layer. In order to display the contents of the input and output tensors onto the window, a compute shader is run after the neural network which 'draws' the two tensors into an image which is then blitted to the window. The diagram below shows how this works: + +image::./images/flow.svg[Sample] + +The image below shows how this sample will look when running: + +image::./images/sample.png[Sample] + +== Graph Pipelines + +image::./images/network.svg[Sample,align="center"] + +The neural network is executed using a new type of pipeline called a _data graph pipeline_. The overall flow when using data graph pipelines is very similar to using compute or graphics pipelines. Our neural network will be encapsulated into a data graph pipeline that can be dispatched using a command buffer. Similarly to compute or graphics pipelines, data graph pipelines can access resources defined outside of the pipeline via descriptor sets and their external interface has to be described using a pipeline layout. Therefore we'll need to create a descriptor set layout and a pipeline layout to that effect. Then we will create the pipeline itself. Data graph pipelines need state and memory to run. Both are encapsulated in a resource called a _data graph pipeline session_. We will create one for our pipeline. We will then create tensor objects for the input and output to our network, descriptor sets to communicate these objects and, finally, record a dispatch command in a command buffer to execute our network. + +In summary, we need to create these objects: + +1. A descriptor set layout and pipeline layout to describe the interface with our data graph pipeline + +2. A data graph pipeline to encapsulate the behavior of our neural network + +3. A data graph pipeline session within which the data graph pipeline can run + +4. Tensor objects for our network's input and output + +5. Descriptor sets to communicate these tensor resources to our data graph pipeline + +=== Pipeline interface === + +The external interface to our pipeline is described using descriptor set layouts and pipeline layouts, just like for compute or graphics pipelines. Here’s the interface we will use: + +image::./images/pipeline_interface.svg[Sample,align="center"] + +The code to create these objects is in the `prepare_data_graph_pipeline` method, but calls out to a helper class `DataGraphPipelineLayout` to do most of the work. The `DataGraphPipelineLayout` constructor creates a single `VkDescriptorSetLayout` containing the two tensor bindings (the binding numbers of the tensors are passed as parameters) and then creates a `VkPipelineLayout` from the descriptor set layout: + +[source,cpp,options="nowrap"] +---- +std::set tensor_bindings = {0, 1}; +std::vector layout_bindings; +for (uint32_t binding : tensor_bindings) +{ + VkDescriptorSetLayoutBinding layout_binding{}; + layout_binding.binding = binding; + layout_binding.descriptorCount = 1; + layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TENSOR_ARM; + + // Data graph pipelines don't have shader stages per-se, so VK_SHADER_STAGE_ALL is used. + layout_binding.stageFlags = VK_SHADER_STAGE_ALL; + layout_bindings.push_back(layout_binding); +} + +// Create set layout +VkDescriptorSetLayoutCreateInfo set_layout_create_info + {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO}; +set_layout_create_info.bindingCount = layout_bindings.size(); +set_layout_create_info.pBindings = layout_bindings.data(); + +VK_CHECK(vkCreateDescriptorSetLayout(get_device().get_handle(), + &set_layout_create_info, + nullptr, + &descriptor_set_layout)); + +// Create pipeline layout +VkPipelineLayoutCreateInfo pipeline_layout_create_info + {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO}; +pipeline_layout_create_info.setLayoutCount = 1; +pipeline_layout_create_info.pSetLayouts = &descriptor_set_layout; + +VK_CHECK(vkCreatePipelineLayout(get_device().get_handle(), + &pipeline_layout_create_info, + nullptr, + &get_handle())); +---- + +The pipeline layout object is now ready to use for creating a data graph pipeline. + +=== Pipeline === + +Neural networks can be described using SPIR-V modules and use descriptor sets to access external resources. The contents of the SPIR-V module for this sample is explained further in <>, but for now we will treat it as a closed box, and just need to know that it takes one input tensor, produces one output tensor and performs a pooling operation which reduces the width and height of its input by half. + +The code to create the pipeline is in the `prepare_data_graph_pipeline` method, just after creating the pipeline layout. As with the layout, a helper class `DataGraphPipeline` does most of the work. + +Before we can create a data graph pipeline from a SPIR-V module, we need to create a `VkShaderModule` object to encapsulate that module, as would be done for compute or graphics pipelines: + +[source,cpp,options="nowrap"] +---- +// This could be created using the SPIR-V assembler or from other tooling (see Appendix A) +std::vector spvcode; + +// Create shader module from binary +VkShaderModuleCreateInfo module_create_info{}; +module_create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; +module_create_info.codeSize = spvcode.size() * 4; +module_create_info.pCode = spvcode.data(); + +VkShaderModule shader_module; +VK_CHECK(vkCreateShaderModule(get_device().get_handle(), &module_create_info, NULL, &shader_module)); +---- + +Now that we have a `VkShaderModule` for our neural network, we can create a data graph pipeline for it. Data graph pipelines are created using `vkCreateDataGraphPipelinesARM` in a manner similar to how other types of pipelines are created. We also need to provide additional information about the resources accessed by the pipeline via descriptor sets. This information is not present in the SPIR-V module, but needs to be known when creating the pipeline, so is provided here. For each resource binding that is part of the pipeline layout, a `VkDataGraphPipelineResourceInfoARM` must be provided which describes the dimensions, memory layout and element type for each tensor. The `DataGraphPipeline` constructor takes this information as a parameter: + +[source,cpp,options="nowrap"] +---- +// Create array of data graph pipeline resource infos (one for each input/output tensor) +// Use std::list for VkDataGraphPipelineResourceInfoTensorARMs so that the addresses don't +// change as we add (because resource_infos will point to these) +std::list tensor_description_list; +std::vector resource_infos; +for (const auto &tensor_descriptions_set : tensor_descriptions) +{ + uint32_t set_idx = tensor_descriptions_set.first; + const std::map &tensor_descriptions_this_set = + tensor_descriptions_set.second; + + for (const auto &tensor_description_binding : tensor_descriptions_this_set) + { + VkTensorDescriptionARM tensor_description = tensor_description_binding.second; + tensor_description_list.push_back(tensor_description); + + VkDataGraphPipelineResourceInfoARM resource_info = + {VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM}; + // Note we use the copy that we saved in the list, not the local stack copy! + resource_info.pNext = &tensor_description_list.back(); + resource_info.descriptorSet = set_idx; + resource_info.binding = tensor_description_binding.first; + resource_infos.push_back(resource_info); + } +} + +// Create data graph pipeline +VkDataGraphPipelineShaderModuleCreateInfoARM pipeline_shader_module_create_info + {VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM}; +pipeline_shader_module_create_info.module = shader_module; +pipeline_shader_module_create_info.pName = entry_point; + +VkDataGraphPipelineCreateInfoARM pipeline_create_info + {VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM}; +pipeline_create_info.pNext = &pipeline_shader_module_create_info; +pipeline_create_info.layout = layout; +pipeline_create_info.resourceInfoCount = resource_infos.size(); +pipeline_create_info.pResourceInfos = resource_infos.data(); + +VK_CHECK(vkCreateDataGraphPipelinesARM(get_device().get_handle(), + VK_NULL_HANDLE, + VK_NULL_HANDLE, + 1, + &pipeline_create_info, + nullptr, + &get_handle())); +---- + +The data graph pipeline object is now created, but needs a session before it can be used. + +=== Pipeline session === + +A data graph pipeline needs state to execute, for example to store the results of any intermediate operations in the neural network. The implementation handles all this internally but it does need some memory to be provided. This state is encapsulated into _data graph pipeline session_ objects. + +This session object is created in the `prepare_data_graph_pipeline` method, just after creating the pipeline itself. As with the pipeline, a helper class `DataGraphPipelineSession` does most of the work. Because sessions need to be bound to memory (just like images and buffers), the sample code makes use of the _Vulkan Memory Allocator_ (VMA) framework to abstract away the details of the memory allocation. This is wrapped up in the function `vmaCreateDataGraphPipelineSession` which is written to be very similar to the existing `vmaCreateImage/vmaCreateBuffer` functions. As with buffers and images, the session is created without any backing memory and then its memory requirements are queried. We can then allocate some appropriate memory and bind it to the session: + +[source,cpp,options="nowrap"] +---- +// 1. Create DataGraphPipelineSession. +VkResult res = vkCreateDataGraphPipelineSessionARM( + device, + pDataGraphPipelineSessionCreateInfo, + nullptr, + pDataGraphPipelineSession); +if (res >= 0) +{ + // 2. Query valid bind points for the session + VkDataGraphPipelineSessionBindPointRequirementsInfoARM bind_point_req_info = + {VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM}; + bind_point_req_info.session = *pDataGraphPipelineSession; + uint32_t requirement_count = 0; + + res = vkGetDataGraphPipelineSessionBindPointRequirementsARM( + device, &bind_point_req_info, &requirement_count, nullptr); + if (res != VK_SUCCESS) + { + return res; + } + + if (requirement_count > 1) + { + // A session could require more than one bind point, + // but for simplicity we only support one bind point type in this function. + return VK_ERROR_INITIALIZATION_FAILED; + } + + VkDataGraphPipelineSessionBindPointRequirementARM bind_point_requirement{ + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM}; + res = vkGetDataGraphPipelineSessionBindPointRequirementsARM( + device, &bind_point_req_info, &requirement_count, &bind_point_requirement); + if (res != VK_SUCCESS) + { + return res; + } + + if (bind_point_requirement.numObjects > 1) + { + // A single bind point requirement could require more than one object, + // but for simplicity we only support one object type in this function. + return VK_ERROR_INITIALIZATION_FAILED; + } + if (bind_point_requirement.bindPointType != VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM) + { + // Currently we only support the memory bind point type + return VK_ERROR_INITIALIZATION_FAILED; + } + + // 3. vkGetDataGraphPipelineSessionMemoryRequirements. + VkDataGraphPipelineSessionBindPointARM memory_bind_point = + VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM; + VkMemoryRequirements2 vkMemReq = {VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2}; + VkDataGraphPipelineSessionMemoryRequirementsInfoARM memory_requirements_info = + {VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM}; + memory_requirements_info.session = *pDataGraphPipelineSession; + memory_requirements_info.bindPoint = memory_bind_point; + memory_requirements_info.objectIndex = 0; + vkGetDataGraphPipelineSessionMemoryRequirementsARM(device, &memory_requirements_info, &vkMemReq); + + if (vkMemReq.memoryRequirements.size > 0) + { + // 4. Allocate memory using allocator. + VmaAllocationInfo allocation_info; + res = vmaAllocateMemory(allocator, + &vkMemReq.memoryRequirements, + pAllocationCreateInfo, + pAllocation, + &allocation_info); + + if (res >= 0) + { + if (pAllocationInfo != nullptr) + { + // Return allocation info to caller, if requested + *pAllocationInfo = allocation_info; + } + + // 5. Bind session with memory. + if ((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0) + { + VkBindDataGraphPipelineSessionMemoryInfoARM bind_info = + {VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM}; + bind_info.session = *pDataGraphPipelineSession; + bind_info.memory = allocation_info.deviceMemory; + bind_info.memoryOffset = allocation_info.offset; + bind_info.bindPoint = memory_bind_point; + bind_info.objectIndex = 0; + res = vkBindDataGraphPipelineSessionMemoryARM(device, 1, &bind_info); + } + if (res >= 0) + { + // All steps succeeded. + return VK_SUCCESS; + } + + // Cleanup in case of errors + vmaFreeMemory(allocator, *pAllocation); + *pAllocation = VK_NULL_HANDLE; + vkDestroyDataGraphPipelineSessionARM(device, *pDataGraphPipelineSession, nullptr); + *pDataGraphPipelineSession = VK_NULL_HANDLE; + return res; + } + + // Cleanup in case of errors + vkDestroyDataGraphPipelineSessionARM(device, *pDataGraphPipelineSession, nullptr); + *pDataGraphPipelineSession = VK_NULL_HANDLE; + return res; + } +} +return res; +---- + +The session object is now ready to use, but we'll need some tensors to provide as input and output. + +=== Tensors + +Tensor resources are created and used in a similar fashion to Vulkan images and buffers: + +1. They are created from a description (size, tiling, usage, etc) + +2. Their memory requirements are queried + +3. We allocate memory compatible with those requirements + +4. We bind the tensor resource to the memory we allocated + +5. We create a view of the tensor resource for use with pipelines + +In the sample code, this is handled by the helper classes `Tensor` and `TensorView` which are analogous to the `Image`/`Buffer` and `ImageView`/`BufferView` classes in the common sample framework. Similar to data graph pipeline sessions discussed above, the sample code makes use of the _Vulkan Memory Allocator_ (VMA) framework to abstract away the details of the memory allocation for tensors. This is wrapped up in the function `vmaCreateTensor` which is written to be very similar to the existing `vmaCreateImage/vmaCreateBuffer` functions. As with buffers and images, the tensor is created without any backing memory and then its memory requirements are queried. We can then allocate some appropriate memory and bind it to the session: + +[source,cpp,options="nowrap"] +---- +// 1. Create VkTensor, using create_info from TensorBuilder +// In this case we are going to represent a small RGB image, so have a batch size of 1, a width and height of 10 and 3 channels. +std::vector dimensions = {1, 10, 10, 3}; +TensorBuilder tensorBuilder = TensorBuilder(dimensions) + .with_tiling(VK_TENSOR_TILING_LINEAR_ARM) + .with_usage(VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM) + .with_format(VK_FORMAT_R32_SFLOAT) + .with_vma_required_flags(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)); + +VkTensorARM tensor = VK_NULL_HANDLE; +VkTensorCreateInfoARM create_info = builder.get_create_info(); +VkResult res = vkCreateTensorARM(device, create_info, nullptr, tensor); + +if (res != VK_SUCCESS) +{ + throw std::runtime_error("Vulkan error: vkCreateTensorARM failed."); +} + +// 2. vkGetTensorMemoryRequirements. +VkMemoryRequirements2 vkMemReq = {}; +VkTensorMemoryRequirementsInfoARM memory_requirements_info = + {VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM}; +memory_requirements_info.tensor = tensor; + +vkGetTensorMemoryRequirementsARM(device, &memory_requirements_info, &vkMemReq); + +// 3. Allocate memory using allocator. +VmaAllocater& allocator = vkb::allocated::get_memory_allocator(); +VmaAllocationCreateInfo alloc_create_info = {}; +VmaAllocation allocation = VK_NULL_HANDLE; +VmaAllocationInfo allocation_info; + +res = vmaAllocateMemory(allocator, + &vkMemReq.memoryRequirements, + alloc_create_info, + allocation, + &allocation_info); + +if (res != VK_SUCCESS) +{ + throw std::runtime_error("Vulkan error: vmaAllocateMemory failed."); +} + +// 4. Bind tensor with memory. +VkBindTensorMemoryInfoARM bind_info = {VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM}; +bind_info.tensor = tensor; +bind_info.memory = allocation_info.deviceMemory; +bind_info.memoryOffset = allocation_info.offset; +res = vkBindTensorMemoryARM(device, 1, &bind_info); + +if (res != VK_SUCCESS) +{ + throw std::runtime_error("Vulkan error: vkBindTensorMemoryARM failed."); +} +---- + +The `VkTensorCreateInfoARM` struct is provided to the `Tensor` constructor through a `TensorBuilder` object which provides a convenient way of making the create info with sensible default values, similar to the `ImageBuilder` and `BufferBuilder` classes which the common sample framework provides. + +The `TensorView` constructor takes a `Tensor` and constructs a view for it, which specifies how the data in a tensor is presented to the pipeline that is using it. Most often, we just want direct access to the tensor data so the format of the view matches that of the tensor. + +[source,cpp,options="nowrap"] +---- +if (format == VK_FORMAT_UNDEFINED) +{ + // VK_FORMAT_UNDEFINED means to use the same format as the provided tensor. + format = tensor.get_format(); +} + +VkTensorViewCreateInfoARM view_info{VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM}; +view_info.tensor = tensor.get_handle(); +view_info.format = format; +VK_CHECK(vkCreateTensorViewARM(get_device().get_handle(), &view_info, nullptr, &get_handle())); +---- + +We create a `Tensor` and a corresponding `TensorView` in each the `prepare_input_tensor` and `prepare_output_tensor` methods, for use as the input and output of our neural network. In both cases we describe the tensor as four-dimensional and with an element format of `VK_FORMAT_R32_SFLOAT` (i.e. 32-bit floating point). We also declare that we will use these tensors from a graph pipeline via the `VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM` usage flag. + +Tensors are often four-dimensional, representing batch size, height, width and channels. In this sample our input tensor will represent a small RGB image, so has a batch size of 1, a width and height of 10 and 3 channels. The output will be half the width and height (reduced by the pooling operation of the neural network), but still 3 channels. + +The input tensor will have some initial, fixed data uploaded to it from the CPU and so needs to be linearly-tiled. This may not be the most efficient memory layout, but it makes the tensor a host-accessible subresource so that we know how the data is laid out. We generate a simple pattern of colors, as can be seen on the _input tensor_ in the screenshot at the top of this page. The data is uploaded by mapping the backing memory of the tensor to get a CPU-accesssible pointer, writing through that pointer, and unmapping the memory. This is handled for us by the VMA framework, and is identical to how you could upload data for an image or buffer. + +The tensor objects are now ready to use, and we can place them in a descriptor set to provide them to the data graph pipeline. + +=== Descriptor sets + +_Descriptor sets_ are used to provide tensor resources to data graph pipelines, just as they are used to provide images and buffers to compute and graphics pipelines. This is done in the `prepare_data_graph_pipeline_descriptor_set` method, which allocates a single descriptor set from a pool (using the descriptor set layout created as part of the `DataGraphPipelineLayout`) and then fills in the descriptor bindings for the input and output tensor views: + +[source,cpp,options="nowrap"] +---- +// Allocate descriptor set using the layout of the Data Graph Pipeline +VkDescriptorSetAllocateInfo alloc_info = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO}; +alloc_info.descriptorPool = descriptor_pool; +alloc_info.descriptorSetCount = 1; +alloc_info.pSetLayouts = &data_graph_pipeline_layout->get_descriptor_set_layout(); + +VK_CHECK(vkAllocateDescriptorSets(get_device().get_handle(), + &alloc_info, + &data_graph_pipeline_descriptor_set)); + +// Write bindings to it, telling it which tensors to use as input and output +std::map tensor_bindings = +{ + // Binding 0 is the input tensor + {0, VkWriteDescriptorSetTensorInfoARM{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_INFO_ARM, + nullptr, 1, &input_tensor_view->get_handle()}}, + // Binding 1 is the output tensor + {1, VkWriteDescriptorSetTensorInfoARM{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_INFO_ARM, + nullptr, 1, &output_tensor_view->get_handle()}} +}; + +std::vector writes; +for (const auto &tensor_binding : tensor_bindings) +{ + VkWriteDescriptorSet write{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET}; + write.dstSet = data_graph_pipeline_descriptor_set; + write.dstBinding = tensor_binding.first; + write.descriptorType = VK_DESCRIPTOR_TYPE_TENSOR_ARM; + // Tensor info is provided via pNext, rather than a pTensorInfo like for images/buffers + write.pNext = &tensor_binding.second; + write.descriptorCount = 1; + writes.push_back(write); +} + +vkUpdateDescriptorSets(get_device().get_handle(), writes.size(), writes.data(), 0, nullptr); +---- + +The descriptor set is now ready to use, and we have everything we need to run an inference! + +=== Command buffer + +Similar to how compute and graphics pipelines are executed, data graph pipelines need to be bound to a dedicated bind point on a command buffer, descriptor sets need to be bound to provide resources to the pipeline, and then they can be dispatched. This is done in the `draw_renderpass` method which is called to record a new command buffer every frame: + +[source,cpp,options="nowrap"] +---- +// Bind and run data graph pipeline. +vkCmdBindPipeline(command_buffer.get_handle(), + VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM, + data_graph_pipeline->get_handle()); +vkCmdBindDescriptorSets(command_buffer.get_handle(), + VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM, data_graph_pipeline_layout->get_handle(), + 0, + 1, + &data_graph_pipeline_descriptor_set, + 0, + nullptr); +vkCmdDispatchDataGraphARM(command_buffer.get_handle(), data_graph_pipeline_session->get_handle()); +---- + +That's all that's necessary to run a simple neural network using a data graph pipeline, but there are more details to cover for using the extensions in more practical use cases. + +== Practical Use + +The tensor object which is written to by the data graph pipeline can be used in numerous ways. In this sample we are reading from it using a compute shader which produces the simple visualization of the tensor contents which is drawn on the window. There are also several other options for how to use the output tensor: + +* Read directly from other shaders by binding it as a Tensor resource, as we do in this sample. +* Aliased as a regular `VkImage` and used as a texture to be sampled from in another shader. +* Aliased as a regular `VkBuffer` and read from in another shader +* Mapped to host-accessible memory and read back for further processing on the CPU + +There is also the question of how to produce inputs for the neural network - in this example we simply uploaded some fixed data from the CPU but there are also many options here (equivalent to the above): + +* Write directly from other shaders by binding it as a Tensor resource. +* Aliased as a regular `VkImage` and written to via. a render target (or writable texture). +* Aliased as a regular `VkBuffer` and written to from another shader. +* Mapped to host-accessible memory and written to with data produced on the CPU, as we do in this sample. + +Accesses to tensor resources must be synchronised correctly, just as for images and buffers. This normally involves adding barriers to the command buffer to ensure that accesses happen in the expected order and that data is visible to the required pipeline stages. There is a new kind of barrier, a Tensor Memory Barrier (analogous to the existing Image Memory Barriers and Buffer Memory Barriers) which can be used for this purpose. The later samples in this series make more use of these. + +== Conclusion + +In this sample we've introduced the VK_ARM_tensors and VK_ARM_data_graph extensions and shown how to use them to run a simple neural network. We've shown the steps needed to run a neural network - creating a pipeline layout, data graph pipeline, data graph pipeline session, tensor objects, descriptor sets and finally recording binding and dispatch commands in a command buffer. The following samples in xref:samples/extensions/tensor_and_data_graph/README.adoc[this series] build upon these concepts. + +== Appendix A: SPIR-V programs for neural networks + +Neural networks can be described using SPIR-V modules, but unlike SPIR-V modules for graphics and compute shaders, there is no GLSL or HLSL syntax for expressing SPIR-V modules for data graph pipelines. There are tools available for generating the SPIR-V code from higher level representations of neural networks such as PyTorch or TensorFlow models (see: link:https://github.com/arm/ai-ml-sdk-model-converter[ML SDK Model Converter]). +However, for this sample we have written the SPIR-V code directly in low-level SPIR-V assembly language to avoid bringing in more dependencies and to give some idea of how the SPIR-V code looks. It is unlikely in practice that you would manually write SPIR-V assembly, however below is a quick overview of SPIR-V for context. + +The assembly code is in the link:../../../../shaders/tensor_and_data_graph/simple_tensor_and_data_graph/spirv/pooling.spvasm[pooling.spvasm] file and is assembled into SPIR-V binary code using `spirv-as` as part of the link:../../../../bldsys/cmake/sample_helper.cmake[build system]. Note this is exactly the same process that would be used to compile compute or graphics shaders from SPIR-V assembly, although typically these would be compiled from GLSL or HLSL instead. + +=== Boilerplate + +The SPIR-V assembly starts with the usual list of capabilities and extensions. Here, we declare that we will make use of the link:https://github.khronos.org/SPIRV-Registry/extensions/ARM/SPV_ARM_graph.html[Graph] and link:https://github.khronos.org/SPIRV-Registry/extensions/ARM/SPV_ARM_tensors.html[Tensors] SPIR-V extensions: + +[source,cpp,options="nowrap"] +---- + OpCapability Shader + OpCapability TensorsARM + OpCapability GraphARM + OpExtension "SPV_ARM_tensors" + OpExtension "SPV_ARM_graph" +---- + +Next is an important line which imports link:https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#_extended_instruction_sets[external instructions] for all of the neural network operations. This defines operations like convolution, pooling, matmul which come from the https://www.mlplatform.org/tosa/[TOSA specification]. + +[source,cpp,options="nowrap"] +---- + %tosa = OpExtInstImport "TOSA.001000.1" +---- + +=== Descriptor set interface + +The next section declares the descriptor set and bindings that form the interface between the Vulkan API data graph pipeline and the SPIR-V module, and is what we used when defining our pipeline layout in the <> section. + +image::./images/pipeline_interface.svg[Sample,align="center"] + +[source,cpp,options="nowrap"] +---- + OpDecorate %input_tensor_ptr DescriptorSet 0 + OpDecorate %input_tensor_ptr Binding 0 + OpDecorate %output_tensor_ptr DescriptorSet 0 + OpDecorate %output_tensor_ptr Binding 1 +---- + +Note this is the same as you would find for compute or graphics shaders. + +=== Types and constants + +All the types and constants used in the code are declared next, with the notable inclusion of _tensor types_ and a _graph type_: + +[source,cpp,options="nowrap"] +---- +%float_tensor_r4_s_1_ih_iw_3 = OpTypeTensorARM %float %uint_4 %uint_array_l4_1_ih_iw_3 +%float_tensor_r4_s_1_oh_ow_3 = OpTypeTensorARM %float %uint_4 %uint_array_l4_1_oh_ow_3 + ... + %graph_type = OpTypeGraphARM 1 %float_tensor_r4_s_1_ih_iw_3 %float_tensor_r4_s_1_oh_ow_3 +---- + +This defines two types for tensors - both four-dimensional tensors with 32-bit floating point elements but with different shapes, which matches the tensor description we used in our C++ code for our input and output tensors. It then defines a graph type which takes one input and one output of their respective types. + +=== Interface variables + +We then declare variables for the input and output tensors which are the external interface for the program. Again, this is the same as you would find for compute or graphics shaders: + +[source,cpp,options="nowrap"] +---- + %input_tensor_ptr = OpVariable %ptr_float_tensor_r4_s_1_ih_iw_3 UniformConstant +%output_tensor_ptr = OpVariable %ptr_float_tensor_r4_s_1_oh_ow_3 UniformConstant +---- + +=== Graph definition + +Finally, we declare our graph and list the operations that make up our neural network: + +[source,cpp,options="nowrap"] +---- + OpGraphEntryPointARM %graph "main" %input_tensor_ptr %output_tensor_ptr + %graph = OpGraphARM %graph_type + %in = OpGraphInputARM %float_tensor_r4_s_1_ih_iw_3 %uint_0 + %out = OpExtInst %float_tensor_r4_s_1_oh_ow_3 %tosa AVG_POOL2D %avg_pool_kernel %avg_pool_stride %avg_pool_pad %uint_2 %in %avg_pool_input_zero_point %avg_pool_output_zero_point + OpGraphSetOutputARM %out %uint_0 + OpGraphEndARM +---- + +The `OpGraphEntryPointARM` instruction exports the graph (which will be defined in the lines below) to be visible to our C++ code under the entry point name `"main"`, which we used when creating our data graph <>. It connects the interface variables declared above to the inputs and outputs of the data graph. + +The lines between `OpGraphARM` and `OpGraphEndARM` define the body of our graph and is where the neural network operations are listed. Here we are using a single instruction imported from the TOSA SPIR-V xref:Boilerplate[extended instruction set]: AVG_POOL2D. That instruction requires a number of arguments describing the properties of the pooling operation (the pooling kernel size, striding, etc.). + diff --git a/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/images/flow.dot b/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/images/flow.dot new file mode 100644 index 000000000..7e2006d86 --- /dev/null +++ b/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/images/flow.dot @@ -0,0 +1,26 @@ +// Copyright (c) 2025, Arm Limited and Contributors +digraph D { + + { + rank=same; + input_tensor[shape=ellipse] + output_tensor[shape=ellipse] + data_graph_pipeline[shape=box] + } + { + rank=same; + output_image[shape=ellipse] + swapchain[shape=ellipse] + + visualization_pipeline[shape=box] + blit[shape=box] + } + + input_tensor -> data_graph_pipeline + data_graph_pipeline -> output_tensor + + input_tensor -> visualization_pipeline + output_tensor -> visualization_pipeline + visualization_pipeline -> output_image -> blit -> swapchain + +} \ No newline at end of file diff --git a/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/images/flow.svg b/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/images/flow.svg new file mode 100644 index 000000000..0a4ceb8f5 --- /dev/null +++ b/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/images/flow.svg @@ -0,0 +1,86 @@ + + + + + + + +D + + +input_tensor + +input_tensor + + +data_graph_pipeline + +data_graph_pipeline + + +input_tensor->data_graph_pipeline + + + + +visualization_pipeline + +visualization_pipeline + + +input_tensor->visualization_pipeline + + + + +output_tensor + +output_tensor + + +output_tensor->visualization_pipeline + + + + +data_graph_pipeline->output_tensor + + + + +output_image + +output_image + + +blit + +blit + + +output_image->blit + + + + +swapchain + +swapchain + + +visualization_pipeline->output_image + + + + +blit->swapchain + + + + + diff --git a/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/images/network.svg b/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/images/network.svg new file mode 100644 index 000000000..8de2949ab --- /dev/null +++ b/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/images/network.svg @@ -0,0 +1,40 @@ + + + + +Overview + + + +Input Tensor + +Input Tensor + + + +Neural Network + +Neural Network + + + +Input Tensor->Neural Network + + + + + +Output Tensor + +Output Tensor + + + +Neural Network->Output Tensor + + + + + diff --git a/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/images/pipeline_interface.svg b/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/images/pipeline_interface.svg new file mode 100644 index 000000000..386993357 --- /dev/null +++ b/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/images/pipeline_interface.svg @@ -0,0 +1,19 @@ + + + + +dset + +Descriptor set 0 + + +node0 + +Binding 0 (Input Tensor) + +Binding 1 (Output Tensor) + + + diff --git a/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/images/sample.png b/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/images/sample.png new file mode 100644 index 000000000..22af5a566 Binary files /dev/null and b/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/images/sample.png differ diff --git a/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/simple_tensor_and_data_graph.cpp b/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/simple_tensor_and_data_graph.cpp new file mode 100644 index 000000000..2c248d09d --- /dev/null +++ b/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/simple_tensor_and_data_graph.cpp @@ -0,0 +1,403 @@ +/* Copyright (c) 2024-2025, Arm Limited and Contributors + * + * SPDX-License-Identifier: Apache-2.0 + * + * 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 "simple_tensor_and_data_graph.h" + +#include + +SimpleTensorAndDataGraph::SimpleTensorAndDataGraph() +{ + set_api_version(VK_API_VERSION_1_3); // Required by the emulation layers + + // Declare that we need the data graph and tensor extensions + add_device_extension("VK_ARM_tensors"); + add_device_extension("VK_ARM_data_graph"); + // These extensions are dependencies of the above, so we need to add them too. + add_device_extension("VK_KHR_maintenance5"); + add_device_extension("VK_KHR_deferred_host_operations"); +} + +SimpleTensorAndDataGraph::~SimpleTensorAndDataGraph() +{ + if (data_graph_pipeline_descriptor_set != VK_NULL_HANDLE) + { + vkFreeDescriptorSets(get_device().get_handle(), descriptor_pool, 1, &data_graph_pipeline_descriptor_set); + } + if (descriptor_pool != VK_NULL_HANDLE) + { + vkDestroyDescriptorPool(get_device().get_handle(), descriptor_pool, nullptr); + } + + // Make sure resources created in the render pipeline are destroyed before the Device gets destroyed. + set_render_pipeline(nullptr); +} + +/** + * @brief Overridden to declare that we require some physical device features to be enabled. + */ +void SimpleTensorAndDataGraph::request_gpu_features(vkb::core::PhysicalDeviceC &gpu) +{ + REQUEST_REQUIRED_FEATURE(gpu, VkPhysicalDeviceVulkan12Features, shaderInt8); + REQUEST_REQUIRED_FEATURE(gpu, VkPhysicalDeviceVulkan13Features, synchronization2); + + // TODO: Re-enable this feature once the emulation layer advertises it + // REQUEST_REQUIRED_FEATURE(gpu, VkPhysicalDeviceTensorFeaturesARM, tensors); + + // Enable the features for tensors and data graphs which we intend to use. + REQUEST_REQUIRED_FEATURE(gpu, VkPhysicalDeviceTensorFeaturesARM, shaderTensorAccess); + + // TODO: Re-enable this feature once the emulation layer advertises it + // REQUEST_REQUIRED_FEATURE(gpu, VkPhysicalDeviceDataGraphFeaturesARM, dataGraph); + + // Update-after-bind is required for the emulation layer + REQUEST_REQUIRED_FEATURE(gpu, VkPhysicalDeviceVulkan12Features, descriptorBindingUniformBufferUpdateAfterBind); + + // Enable Int64, if available. + if (gpu.get_features().shaderInt64) + { + gpu.get_mutable_requested_features().shaderInt64 = VK_TRUE; + } + else + { + throw std::runtime_error("Required feature VkPhysicalDeviceFeatures::shaderInt64 is not supported."); + } +} + +/** + * @brief Overridden to create and set up Vulkan resources. + */ +bool SimpleTensorAndDataGraph::prepare(const vkb::ApplicationOptions &options) +{ + if (!VulkanSample::prepare(options)) + { + return false; + } + + // We use the GUI framework for labels on the visualization + create_gui(*window, &get_stats()); + + // Create Vulkan resources + prepare_descriptor_pool(); + prepare_input_tensor(); + prepare_output_tensor(); + prepare_output_image(get_render_context().get_surface_extent().width, get_render_context().get_surface_extent().height); + prepare_data_graph_pipeline(); + prepare_data_graph_pipeline_descriptor_set(); + prepare_visualization_pipeline(); + prepare_visualization_pipeline_descriptor_set(); + + // Create a RenderPipeline to blit `output_image` to the swapchain + std::unique_ptr render_pipeline = std::make_unique(); + render_pipeline->add_subpass(std::make_unique(get_render_context())); + set_render_pipeline(std::move(render_pipeline)); + + return true; +} + +/* + * Creates a descriptor pool which can be used to allocate descriptors for tensor and image bindings. + * Note we can't use vkb::DescriptorPool because it doesn't know about tensors. + */ +void SimpleTensorAndDataGraph::prepare_descriptor_pool() +{ + std::vector descriptor_pool_sizes = { + {VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 10}, // Fairly arbitrary counts + {VK_DESCRIPTOR_TYPE_TENSOR_ARM, 10}, + }; + + VkDescriptorPoolCreateInfo create_info{VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO}; + create_info.poolSizeCount = descriptor_pool_sizes.size(); + create_info.pPoolSizes = descriptor_pool_sizes.data(); + create_info.maxSets = 10; // Fairly arbitrary + create_info.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT; + + VK_CHECK(vkCreateDescriptorPool(get_device().get_handle(), &create_info, nullptr, &descriptor_pool)); +} + +/* + * Creates the Tensor used as input to the neural network and fills it with some initial data. + * Also creates a Tensor View (analogous to an Image View). + */ +void SimpleTensorAndDataGraph::prepare_input_tensor() +{ + // Tensors are often four-dimensional, representing batch size, height, width and channels. + // In this case we are going to represent a small RGB image, so have a batch size of 1, a width and height of 10 and 3 channels. + std::vector dimensions = {1, 10, 10, 3}; + // Create tensor and back it with memory. Set linear tiling flags and host-visible VMA flags so the backing memory can updated from the CPU. + input_tensor = std::make_unique(get_device(), + TensorBuilder(dimensions) + .with_tiling(VK_TENSOR_TILING_LINEAR_ARM) + .with_usage(VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM) + .with_format(VK_FORMAT_R32_SFLOAT) + .with_vma_required_flags(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)); + // Upload fixed initial data - smoothly varying colors over the square + std::vector input_tensor_data; + for (int y = 0; y < dimensions[1]; ++y) + { + float v = y / float(dimensions[1]); + for (int x = 0; x < dimensions[2]; ++x) + { + float u = x / float(dimensions[2]); + input_tensor_data.push_back(glm::fvec3{u, 1 - u, v}); + } + } + input_tensor->update(input_tensor_data); + + input_tensor_view = std::make_unique(*input_tensor); +} + +/* + * Creates the Tensor used as output from the neural network. + * Also creates a Tensor View (analogous to an Image View). + */ +void SimpleTensorAndDataGraph::prepare_output_tensor() +{ + // The output of the network is half the width and height of the input, but still RGB. + std::vector dimensions = {1, 5, 5, 3}; + // Create tensor and back it with memory + output_tensor = std::make_unique(get_device(), + TensorBuilder(dimensions) + .with_usage(VK_TENSOR_USAGE_SHADER_BIT_ARM | VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM) + .with_format(VK_FORMAT_R32_SFLOAT)); + output_tensor_view = std::make_unique(*output_tensor); +} + +/* + * Creates the Image used to visualize the two tensors, which is then blitted to the Swapchain. + * Also creates a Image View. + */ +void SimpleTensorAndDataGraph::prepare_output_image(uint32_t width, uint32_t height) +{ + output_image = std::make_unique(get_device(), + vkb::core::ImageBuilder(VkExtent3D{width, height, 1}) + .with_format(VK_FORMAT_R8G8B8A8_UNORM) + .with_usage(VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT)); + output_image_view = std::make_unique(*output_image, VK_IMAGE_VIEW_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM); +} + +/* + * Creates the Pipeline Layout, a Data Graph Pipeline and a Data Graph Pipeline Session used to run the neural network. + */ +void SimpleTensorAndDataGraph::prepare_data_graph_pipeline() +{ + // Create the Pipeline Layout. This is equivalent to the pipeline layout for compute or data graph pipelines, describing what bind points are available. + // The neural network has its input tensor on binding 0 and its output tensor at binding 1. + // + // In order to create the layout, we just need to know which binding slots are tensors - no further details needed yet. + std::set tensor_bindings = {0, 1}; + data_graph_pipeline_layout = std::make_unique(get_device(), tensor_bindings); + + // Create a Pipeline from the layout. This is equivalent to a graphics or compute pipeline and contains a shader module which describes the + // neural network to execute (see `pooling.spvasm` for the SPIR-V code). It also requires the description (shape etc.) of the tensors that will + // be bound to the pipeline. + std::map> tensor_descriptions; + // All bindings are in set 0 + tensor_descriptions[0] = + { + // Binding 0 is the input tensor + {0, &input_tensor->get_description()}, + // Binding 1 is the output tensor + {1, &output_tensor->get_description()}}; + + VkShaderModule shader_module = vkb::load_shader("tensor_and_data_graph/simple_tensor_and_data_graph/spirv/pooling.spvasm.spv", get_device().get_handle(), VK_SHADER_STAGE_ALL); + + data_graph_pipeline = std::make_unique(get_device(), + data_graph_pipeline_layout->get_handle(), + shader_module, + "main", + tensor_descriptions); + + // Create a Pipeline Session for the Pipeline. Unlike compute and graphics pipelines, data graph pipelines require + // additional state to be stored (e.g. for intermediate results). This is stored separately to the pipeline itself in + // 'pipeline session' resource. This requires memory to be allocated and bound to it (similar to a buffer), which is all handled + // inside our helper class DataGraphPipelineSession + VmaAllocationCreateInfo alloc_create_info = {}; + data_graph_pipeline_session = std::make_unique(get_device(), data_graph_pipeline->get_handle(), alloc_create_info); +} + +/* + * Allocates and fills in a Descriptor Set to provide bindings to the Data Graph Pipeline. + */ +void SimpleTensorAndDataGraph::prepare_data_graph_pipeline_descriptor_set() +{ + // Allocate descriptor set using the layout of the Data Graph Pipeline + VkDescriptorSetAllocateInfo alloc_info = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO}; + alloc_info.descriptorPool = descriptor_pool; + alloc_info.descriptorSetCount = 1; + alloc_info.pSetLayouts = &data_graph_pipeline_layout->get_descriptor_set_layout(); + VK_CHECK(vkAllocateDescriptorSets(get_device().get_handle(), &alloc_info, &data_graph_pipeline_descriptor_set)); + + // Write bindings to it, telling it which tensors to use as input and output + std::map tensor_bindings = + { + // Binding 0 is the input tensor + {0, VkWriteDescriptorSetTensorARM{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM, nullptr, 1, &input_tensor_view->get_handle()}}, + // Binding 1 is the output tensor + {1, VkWriteDescriptorSetTensorARM{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM, nullptr, 1, &output_tensor_view->get_handle()}}}; + write_descriptor_set(get_device().get_handle(), data_graph_pipeline_descriptor_set, {}, tensor_bindings); +} + +/* + * Creates the Pipeline Layout and a Compute Pipeline used to run the compute shader which copies input and + * output tensors to an image, so we can see their contents on the screen. + */ +void SimpleTensorAndDataGraph::prepare_visualization_pipeline() +{ + // Load the compute shader + vkb::ShaderModule &visualization_comp = + get_device().get_resource_cache().request_shader_module(VK_SHADER_STAGE_COMPUTE_BIT, vkb::ShaderSource{"tensor_and_data_graph/glsl/visualization_two_tensors.comp.spv"}); + + // Create pipeline layout from the reflected shader code. Note that this will include bindings to Tensor resources, so we use our own + // class to do this, rather than the sample framework's vkb::PipelineLayout. + visualization_pipeline_layout = std::make_unique(get_device(), visualization_comp); + + // Create pipeline from this layout and the shader module. Similar to the layout, we use our own class rather than vkb::ComputePipeline. + visualization_pipeline = std::make_unique(get_device(), visualization_pipeline_layout->get_handle(), visualization_comp); +} + +/* + * Allocates and fills in a Descriptor Set to provide bindings to the visualization Compute Pipeline. + */ +void SimpleTensorAndDataGraph::prepare_visualization_pipeline_descriptor_set() +{ + // Allocate descriptor set (if not already allocated; when this function is called due to window resize we just update the existing set rather than allocating a new one) + if (visualization_pipeline_descriptor_set == VK_NULL_HANDLE) + { + VkDescriptorSetAllocateInfo alloc_info = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO}; + alloc_info.descriptorPool = descriptor_pool; + alloc_info.descriptorSetCount = 1; + alloc_info.pSetLayouts = &visualization_pipeline_layout->get_descriptor_set_layouts().begin()->second; + VK_CHECK(vkAllocateDescriptorSets(get_device().get_handle(), &alloc_info, &visualization_pipeline_descriptor_set)); + } + + // Write bindings to it + std::map tensor_bindings = + { + // Binding 0 is the input tensor + {0, VkWriteDescriptorSetTensorARM{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM, nullptr, 1, &input_tensor_view->get_handle()}}, + // Binding 1 is the output tensor + {1, VkWriteDescriptorSetTensorARM{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM, nullptr, 1, &output_tensor_view->get_handle()}}}; + + std::map image_bindings = + { + // Binding 2 is the output image + {2, VkDescriptorImageInfo{VK_NULL_HANDLE, output_image_view->get_handle(), VK_IMAGE_LAYOUT_GENERAL}}}; + + write_descriptor_set(get_device().get_handle(), visualization_pipeline_descriptor_set, image_bindings, tensor_bindings); +} + +/** + * @brief Overridden to recreate the output_image when the window is resized. + */ +bool SimpleTensorAndDataGraph::resize(uint32_t width, uint32_t height) +{ + // Can't destroy the old image until any outstanding commands are completed + get_device().wait_idle(); + + // Destroy old image and create new one with the new width/height + prepare_output_image(width, height); + + // Update the descriptor set for the visualization pipeline, so that it writes to the new image + prepare_visualization_pipeline_descriptor_set(); + + return true; +} + +/** + * @brief Overridden to do the main rendering on each frame - dispatch our neural network inference and visualize the results. + */ +void SimpleTensorAndDataGraph::draw_renderpass(vkb::core::CommandBufferC &command_buffer, RenderTargetType &render_target) +{ + // Bind and run data graph pipeline. + vkCmdBindPipeline(command_buffer.get_handle(), VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM, data_graph_pipeline->get_handle()); + vkCmdBindDescriptorSets(command_buffer.get_handle(), VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM, data_graph_pipeline_layout->get_handle(), + 0, 1, &data_graph_pipeline_descriptor_set, 0, nullptr); + vkCmdDispatchDataGraphARM(command_buffer.get_handle(), data_graph_pipeline_session->get_handle(), VK_NULL_HANDLE); + + // Barrier for `output_tensor` (written to by the graph pipeline above, and read from by the visualization compute shader below) + VkTensorMemoryBarrierARM tensor_barrier = {VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM}; + tensor_barrier.tensor = output_tensor->get_handle(); + tensor_barrier.srcStageMask = VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM; + tensor_barrier.srcAccessMask = VK_ACCESS_2_SHADER_WRITE_BIT; + tensor_barrier.dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT; + tensor_barrier.dstAccessMask = VK_ACCESS_2_SHADER_READ_BIT; + VkDependencyInfo dependency_info = {VK_STRUCTURE_TYPE_DEPENDENCY_INFO}; + dependency_info.pNext = &tensor_barrier; + vkCmdPipelineBarrier2(command_buffer.get_handle(), &dependency_info); + + // Transition `output_image` to layout for being written to by the visualization compute shader. + // We don't care about the old contents so can use VK_IMAGE_LAYOUT_UNDEFINED as the old layout. + vkb::ImageMemoryBarrier output_image_barrier; + output_image_barrier.old_layout = VK_IMAGE_LAYOUT_UNDEFINED; + output_image_barrier.new_layout = VK_IMAGE_LAYOUT_GENERAL; + output_image_barrier.src_stage_mask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; + output_image_barrier.src_access_mask = VK_ACCESS_SHADER_READ_BIT; + output_image_barrier.dst_stage_mask = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT; + output_image_barrier.dst_access_mask = VK_ACCESS_SHADER_WRITE_BIT; + command_buffer.image_memory_barrier(*output_image_view, output_image_barrier); + + // Bind and run visualization compute pipeline + vkCmdBindPipeline(command_buffer.get_handle(), VK_PIPELINE_BIND_POINT_COMPUTE, visualization_pipeline->get_handle()); + vkCmdBindDescriptorSets(command_buffer.get_handle(), VK_PIPELINE_BIND_POINT_COMPUTE, visualization_pipeline_layout->get_handle(), + 0, 1, &visualization_pipeline_descriptor_set, 0, nullptr); + + // Pass the output_image size as a push constant + vkCmdPushConstants(command_buffer.get_handle(), visualization_pipeline_layout->get_handle(), VK_SHADER_STAGE_COMPUTE_BIT, 0, + sizeof(glm::uvec2), &render_target.get_extent()); + uint32_t group_count_x = (render_target.get_extent().width + 7) / 8; // The visualization shader has a group size of 8 + uint32_t group_count_y = (render_target.get_extent().height + 7) / 8; + vkCmdDispatch(command_buffer.get_handle(), group_count_x, group_count_y, 1); + + // Barrier for `output_image` (written by the visualization compute shader above, read by the BlitSubpass below) + vkb::ImageMemoryBarrier output_image_barrier2; + output_image_barrier2.old_layout = VK_IMAGE_LAYOUT_GENERAL; + output_image_barrier2.new_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + output_image_barrier2.src_stage_mask = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT; + output_image_barrier2.src_access_mask = VK_ACCESS_SHADER_WRITE_BIT; + output_image_barrier2.dst_stage_mask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; + output_image_barrier2.dst_access_mask = VK_ACCESS_SHADER_READ_BIT; + command_buffer.image_memory_barrier(*output_image_view, output_image_barrier2); + + // Call the inherited draw_renderpass function to run our blitting pass to display output_image on the screen, and also draw the GUI. + // The output_image may have been recreated due to window resize since the last frame, so make sure the BlitSubpass has the latest one. + static_cast(*get_render_pipeline().get_subpasses()[0]).set_source(output_image_view.get()); + VulkanSample::draw_renderpass(command_buffer, render_target); +} + +/** + * @brief Overridden to show labels for visualized input and output tensors. + */ +void SimpleTensorAndDataGraph::draw_gui() +{ + float cx = get_render_context().get_surface_extent().width * 0.5f; + float cy = get_render_context().get_surface_extent().height * 0.5f; + + ImDrawList *draw_list = ImGui::GetForegroundDrawList(); + draw_list->AddText(ImVec2(cx - 300, cy + 100), IM_COL32_WHITE, "Input tensor"); + draw_list->AddText(ImVec2(cx + 100, cy + 100), IM_COL32_WHITE, "Output tensor"); + + draw_list->AddLine(ImVec2(cx - 25, cy), ImVec2(cx - 5, cy), IM_COL32_WHITE, 5.0f); + ImGui::RenderArrowPointingAt(draw_list, ImVec2(cx + 25.0f, cy), + ImVec2(30.0f, 10.0f), ImGuiDir_Right, IM_COL32_WHITE); + ImVec2 text_size = ImGui::CalcTextSize("Pooling"); + draw_list->AddText(ImVec2(cx - text_size.x / 2, cy + 20), IM_COL32_WHITE, "Pooling"); +} + +std::unique_ptr create_simple_tensor_and_data_graph() +{ + return std::make_unique(); +} diff --git a/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/simple_tensor_and_data_graph.h b/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/simple_tensor_and_data_graph.h new file mode 100644 index 000000000..c77c8db2f --- /dev/null +++ b/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/simple_tensor_and_data_graph.h @@ -0,0 +1,99 @@ +/* Copyright (c) 2024-2025, Arm Limited and Contributors + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 the "License"; + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include "vulkan_sample.h" + +#include "../tensor_and_data_graph_common.h" + +#include +#include + +/** + * @brief Demonstrates how to use the VK_ARM_tensors and VK_ARM_data_graph extensions in a simple example + * which runs a trivial neural network on a small, hardcoded tensor. + * @details A `Tensor` resource (`input_tensor`) is created and initial contents are uploaded. This is a new resource type analogous + * to Images and Buffers. This is read as an input by a `Data Graph Pipeline` (`data_graph_pipeline`), which is a new type of pipeline analogous + * to Graphics Pipelines and Compute Pipelines. The Data Graph Pipeline runs a neural network and produces an output which is written + * into the `output_tensor` Tensor. + * In order to visualize the results of this pipeline, there is a Compute Pipeline (`visualization_pipeline`) which copies the + * contents of `input_tensor` and `output_tensor` into an Image (`output_image`) which is blitted to the Swapchain. + * + * As a diagram, this looks like: + * + * input_tensor -> data_graph_pipeline -> output_tensor + * \ \. + * \-----------------------------------\--------> visualization_pipeline -> output_image -> blit -> swapchain + * + * Because the common Vulkan Samples framework code is not aware of the Tensor resource type or Data Graph Pipelines, + * generic functionality for these concepts has been added to a new tensor_and_data_graph_common.h/cpp file, which this sample + * (and other tensor and data graph samples) makes use of. + */ +class SimpleTensorAndDataGraph : public vkb::VulkanSampleC +{ + public: + SimpleTensorAndDataGraph(); + ~SimpleTensorAndDataGraph() override; + + void request_gpu_features(vkb::core::PhysicalDeviceC &gpu) override; + + bool prepare(const vkb::ApplicationOptions &options) override; + + bool resize(uint32_t width, uint32_t height) override; + + void draw_renderpass(vkb::core::CommandBufferC &command_buffer, RenderTargetType &render_target) override; + + void draw_gui() override; + + private: + void prepare_descriptor_pool(); + + void prepare_input_tensor(); + void prepare_output_tensor(); + void prepare_output_image(uint32_t width, uint32_t height); + + void prepare_data_graph_pipeline(); + void prepare_data_graph_pipeline_descriptor_set(); + + void prepare_visualization_pipeline(); + void prepare_visualization_pipeline_descriptor_set(); + + std::unique_ptr input_tensor; + std::unique_ptr input_tensor_view; + + std::unique_ptr output_tensor; + std::unique_ptr output_tensor_view; + + std::unique_ptr output_image; + std::unique_ptr output_image_view; + + // Common descriptor pool which can allocate descriptors for tensors and images. + // We're only allocating a small number of descriptors of a few types, so this simple approach works quite well. + VkDescriptorPool descriptor_pool = VK_NULL_HANDLE; + + std::unique_ptr data_graph_pipeline_layout; + std::unique_ptr data_graph_pipeline; + std::unique_ptr data_graph_pipeline_session; + VkDescriptorSet data_graph_pipeline_descriptor_set = VK_NULL_HANDLE; + + std::unique_ptr visualization_pipeline_layout; + std::unique_ptr visualization_pipeline; + VkDescriptorSet visualization_pipeline_descriptor_set = VK_NULL_HANDLE; +}; + +std::unique_ptr create_simple_tensor_and_data_graph(); diff --git a/samples/extensions/tensor_and_data_graph/tensor_and_data_graph_common.cpp b/samples/extensions/tensor_and_data_graph/tensor_and_data_graph_common.cpp new file mode 100644 index 000000000..b63877c93 --- /dev/null +++ b/samples/extensions/tensor_and_data_graph/tensor_and_data_graph_common.cpp @@ -0,0 +1,748 @@ +/* Copyright (c) 2024-2025, Arm Limited and Contributors + * + * SPDX-License-Identifier: Apache-2.0 + * + * 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 "tensor_and_data_graph_common.h" + +#include +#include +#include + +void write_descriptor_set(VkDevice device, + VkDescriptorSet set, + const std::map &image_bindings, + const std::map &tensor_bindings) +{ + std::vector writes; + + for (const auto &image_binding : image_bindings) + { + VkWriteDescriptorSet write{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET}; + write.dstSet = set; + write.dstBinding = image_binding.first; + write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; + write.pImageInfo = &image_binding.second; + write.descriptorCount = 1; + writes.push_back(write); + } + for (const auto &tensor_binding : tensor_bindings) + { + VkWriteDescriptorSet write{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET}; + write.dstSet = set; + write.dstBinding = tensor_binding.first; + write.descriptorType = VK_DESCRIPTOR_TYPE_TENSOR_ARM; + write.pNext = &tensor_binding.second; // Tensor info is provided via pNext, rather than a pTensorInfo like for images/buffers + write.descriptorCount = 1; + writes.push_back(write); + } + + vkUpdateDescriptorSets(device, writes.size(), writes.data(), 0, nullptr); +} + +VkResult vmaCreateTensor(VkDevice device, + VmaAllocator allocator, + const VkTensorCreateInfoARM *pTensorCreateInfo, + const VmaAllocationCreateInfo *pAllocationCreateInfo, + VkTensorARM *pTensor, + VmaAllocation *pAllocation, + VmaAllocationInfo *pAllocationInfo) +{ + // Note that this implementation has some slight differences to the equivalent vmaCreateImage/Buffer functions because we are outside + // the VMA implementation so can't use any of its internal functions and have to use the public APIs instead. + + if (pTensorCreateInfo == nullptr || + pTensorCreateInfo->pDescription == nullptr || + pTensor == nullptr || + pAllocation == nullptr) + { + return VK_ERROR_INITIALIZATION_FAILED; + } + + *pTensor = VK_NULL_HANDLE; + *pAllocation = VK_NULL_HANDLE; + + // 1. Create VkTensor. + VkResult res = vkCreateTensorARM( + device, + pTensorCreateInfo, + nullptr, + pTensor); + if (res >= 0) + { + // 2. vkGetTensorMemoryRequirements. + VkMemoryRequirements2 vkMemReq = {}; + vkMemReq.sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2; + VkTensorMemoryRequirementsInfoARM memory_requirements_info = {VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM}; + memory_requirements_info.tensor = *pTensor; + vkGetTensorMemoryRequirementsARM(device, &memory_requirements_info, &vkMemReq); + + // 3. Allocate memory using allocator. + VmaAllocationInfo allocation_info; + res = vmaAllocateMemory(allocator, + &vkMemReq.memoryRequirements, + pAllocationCreateInfo, + pAllocation, + &allocation_info); + + if (res >= 0) + { + if (pAllocationInfo != nullptr) + { + // Return allocation info to caller, if requested + *pAllocationInfo = allocation_info; + } + + // 4. Bind tensor with memory. + if ((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0) + { + VkBindTensorMemoryInfoARM bind_tensor_memory_info = {VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM}; + bind_tensor_memory_info.tensor = *pTensor; + bind_tensor_memory_info.memory = allocation_info.deviceMemory; + bind_tensor_memory_info.memoryOffset = allocation_info.offset; + res = vkBindTensorMemoryARM(device, 1, &bind_tensor_memory_info); + } + if (res >= 0) + { + // All steps succeeded. + return VK_SUCCESS; + } + vmaFreeMemory(allocator, *pAllocation); + *pAllocation = VK_NULL_HANDLE; + } + vkDestroyTensorARM(device, *pTensor, nullptr); + *pTensor = VK_NULL_HANDLE; + return res; + } + return res; +} + +void vmaDestroyTensor(VkDevice device, + VmaAllocator allocator, + VkTensorARM tensor, + VmaAllocation allocation) +{ + if (tensor != VK_NULL_HANDLE) + { + vkDestroyTensorARM(device, tensor, nullptr); + } + + if (allocation != VK_NULL_HANDLE) + { + vmaFreeMemory(allocator, allocation); + } +} + +VkResult vmaCreateDataGraphPipelineSession(VkDevice device, + VmaAllocator allocator, + const VkDataGraphPipelineSessionCreateInfoARM *pDataGraphPipelineSessionCreateInfo, + const VmaAllocationCreateInfo *pAllocationCreateInfo, + VkDataGraphPipelineSessionARM *pDataGraphPipelineSession, + VmaAllocation *pAllocation, + VmaAllocationInfo *pAllocationInfo) +{ + // Note that this implementation has some slight differences to the equivalent vmaCreateImage/Buffer functions because we are outside + // the VMA implementation so can't use any of its internal functions and have to use the public APIs instead. + + if (pDataGraphPipelineSessionCreateInfo == nullptr || + pDataGraphPipelineSession == nullptr || + pAllocation == nullptr) + { + return VK_ERROR_INITIALIZATION_FAILED; + } + + *pDataGraphPipelineSession = VK_NULL_HANDLE; + *pAllocation = VK_NULL_HANDLE; + + // 1. Create DataGraphPipelineSession. + VkResult res = vkCreateDataGraphPipelineSessionARM( + device, + pDataGraphPipelineSessionCreateInfo, + nullptr, + pDataGraphPipelineSession); + if (res >= 0) + { + // 2. Query valid bind points for the session + VkDataGraphPipelineSessionBindPointRequirementsInfoARM bind_point_req_info = {VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM}; + bind_point_req_info.session = *pDataGraphPipelineSession; + uint32_t requirement_count = 0; + + res = vkGetDataGraphPipelineSessionBindPointRequirementsARM(device, &bind_point_req_info, &requirement_count, nullptr); + if (res != VK_SUCCESS) + { + return res; + } + + if (requirement_count > 1) + { + // A session could require more than one bind point, but for simplicity we only support one bind point type in this function. + return VK_ERROR_INITIALIZATION_FAILED; + } + + VkDataGraphPipelineSessionBindPointRequirementARM bind_point_requirement{VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM}; + res = vkGetDataGraphPipelineSessionBindPointRequirementsARM(device, &bind_point_req_info, &requirement_count, &bind_point_requirement); + if (res != VK_SUCCESS) + { + return res; + } + + if (bind_point_requirement.numObjects > 1) + { + // A single bind point requirement could require more than one object, but for simplicity we only support one object type in this function. + return VK_ERROR_INITIALIZATION_FAILED; + } + if (bind_point_requirement.bindPointType != VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM) + { + // Currently we only support the memory bind point type + return VK_ERROR_INITIALIZATION_FAILED; + } + + // 3. vkGetDataGraphPipelineSessionMemoryRequirements. + VkDataGraphPipelineSessionBindPointARM memory_bind_point = VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM; + VkMemoryRequirements2 vkMemReq = {VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2}; + VkDataGraphPipelineSessionMemoryRequirementsInfoARM memory_requirements_info = {VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM}; + memory_requirements_info.session = *pDataGraphPipelineSession; + memory_requirements_info.bindPoint = memory_bind_point; + memory_requirements_info.objectIndex = 0; + vkGetDataGraphPipelineSessionMemoryRequirementsARM(device, &memory_requirements_info, &vkMemReq); + + if (vkMemReq.memoryRequirements.size > 0) + { + // 4. Allocate memory using allocator. + VmaAllocationInfo allocation_info; + res = vmaAllocateMemory(allocator, + &vkMemReq.memoryRequirements, + pAllocationCreateInfo, + pAllocation, + &allocation_info); + + if (res >= 0) + { + if (pAllocationInfo != nullptr) + { + // Return allocation info to caller, if requested + *pAllocationInfo = allocation_info; + } + + // 5. Bind session with memory. + if ((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0) + { + VkBindDataGraphPipelineSessionMemoryInfoARM bind_info = {VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM}; + bind_info.session = *pDataGraphPipelineSession; + bind_info.memory = allocation_info.deviceMemory; + bind_info.memoryOffset = allocation_info.offset; + bind_info.bindPoint = memory_bind_point; + bind_info.objectIndex = 0; + res = vkBindDataGraphPipelineSessionMemoryARM(device, 1, &bind_info); + } + + if (res >= 0) + { + // All steps succeeded. + return VK_SUCCESS; + } + + // Cleanup in case of errors + vmaFreeMemory(allocator, *pAllocation); + *pAllocation = VK_NULL_HANDLE; + } + + // Cleanup in case of errors + vkDestroyDataGraphPipelineSessionARM(device, *pDataGraphPipelineSession, nullptr); + *pDataGraphPipelineSession = VK_NULL_HANDLE; + } + } + + return res; +} + +void vmaDestroyDataGraphPipelineSession(VkDevice device, + VmaAllocator allocator, + VkDataGraphPipelineSessionARM tensor, + VmaAllocation allocation) +{ + if (tensor != VK_NULL_HANDLE) + { + vkDestroyDataGraphPipelineSessionARM(device, tensor, nullptr); + } + + if (allocation != VK_NULL_HANDLE) + { + vmaFreeMemory(allocator, allocation); + } +} + +TensorBuilder::TensorBuilder(std::vector in_dimensions) : + vkb::allocated::BuilderBaseC(VkTensorCreateInfoARM{VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM}), + dimensions(std::move(in_dimensions)), + description{VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM} +{ + description.dimensionCount = dimensions.size(); + description.pDimensions = dimensions.data(); // Note we point to the dimensions array stored in this object, not the one passed in (which is already empty!) + get_create_info().pDescription = &description; + + alloc_create_info.usage = VMA_MEMORY_USAGE_UNKNOWN; // The default value set by the base class of 'VMA_MEMORY_USAGE_AUTO' won't work for tensors + + description.tiling = VK_TENSOR_TILING_LINEAR_ARM; + description.usage = VK_TENSOR_USAGE_SHADER_BIT_ARM; + description.format = VK_FORMAT_R32_SFLOAT; +} + +TensorBuilder &TensorBuilder::with_format(VkFormat format) +{ + description.format = format; + return *this; +} +TensorBuilder &TensorBuilder::with_tiling(VkTensorTilingARM tiling) +{ + description.tiling = tiling; + return *this; +} +TensorBuilder &TensorBuilder::with_usage(VkTensorUsageFlagsARM usage) +{ + description.usage = usage; + return *this; +} + +TensorDescriptor::TensorDescriptor(const TensorBuilder &builder) +{ + // Note that we need to do a deep copy of this struct as it contains a couple of pointers. + create_info = builder.get_create_info(); + description = *create_info.pDescription; + create_info.pDescription = &description; + dimensions.assign(description.pDimensions, description.pDimensions + description.dimensionCount); + description.pDimensions = dimensions.data(); +} + +const VkTensorCreateInfoARM &TensorDescriptor::get_create_info() const +{ + return create_info; +} + +const VkTensorDescriptionARM &TensorDescriptor::get_description() const +{ + return description; +} + +Tensor::Tensor(vkb::core::DeviceC &device, TensorBuilder const &builder) : + vkb::allocated::AllocatedC(builder.get_allocation_create_info(), nullptr, &device), + descriptor(builder) +{ + VkTensorARM tensor = VK_NULL_HANDLE; + VmaAllocationInfo allocation_info{}; + VmaAllocation allocation = VK_NULL_HANDLE; + VK_CHECK(vmaCreateTensor( + device.get_handle(), + vkb::allocated::get_memory_allocator(), + &descriptor.get_create_info(), + &builder.get_allocation_create_info(), + &tensor, + &allocation, + &allocation_info)); + + set_allocation(allocation); + post_create(allocation_info); + set_handle(tensor); + if (!builder.get_debug_name().empty()) + { + set_debug_name(builder.get_debug_name()); + } +} + +Tensor::~Tensor() +{ + if (get_handle() != VK_NULL_HANDLE && get_allocation() != VK_NULL_HANDLE) + { + unmap(); + vmaDestroyTensor(get_device().get_handle(), vkb::allocated::get_memory_allocator(), get_handle(), get_allocation()); + clear(); + } +} + +const VkTensorDescriptionARM &Tensor::get_description() const +{ + return descriptor.get_description(); +} + +VkFormat Tensor::get_format() const +{ + return descriptor.get_create_info().pDescription->format; +}; + +ExternallyAllocatedTensor::ExternallyAllocatedTensor(vkb::core::DeviceC &device, TensorBuilder const &builder, VkDeviceMemory existing_memory, + VkDeviceSize existing_memory_offset) : + vkb::core::VulkanResourceC(VK_NULL_HANDLE, &device), // Handle will be set later in the constructor + descriptor(builder) +{ + // Create tensor + VkTensorARM tensor = VK_NULL_HANDLE; + VkResult res = vkCreateTensorARM(device.get_handle(), &descriptor.get_create_info(), nullptr, &tensor); + + // Bind it to existing memory + VkBindTensorMemoryInfoARM bind_info = {VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM, + nullptr, tensor, existing_memory, existing_memory_offset}; + vkBindTensorMemoryARM(device.get_handle(), 1, &bind_info); + + set_handle(tensor); + if (!builder.get_debug_name().empty()) + { + set_debug_name(builder.get_debug_name()); + } +} + +ExternallyAllocatedTensor::~ExternallyAllocatedTensor() +{ + if (get_handle() != VK_NULL_HANDLE) + { + vkDestroyTensorARM(get_device().get_handle(), get_handle(), nullptr); + } +} + +const VkTensorDescriptionARM &ExternallyAllocatedTensor::get_description() const +{ + return descriptor.get_description(); +} + +VkFormat ExternallyAllocatedTensor::get_format() const +{ + return descriptor.get_create_info().pDescription->format; +}; + +TensorView::TensorView(Tensor &tensor, VkFormat format) : + vkb::core::VulkanResourceC(VK_NULL_HANDLE, &tensor.get_device()) +{ + Init(tensor, format); +} + +TensorView::TensorView(ExternallyAllocatedTensor &tensor, VkFormat format) : + vkb::core::VulkanResourceC(VK_NULL_HANDLE, &tensor.get_device()) +{ + Init(tensor, format); +} + +template +void TensorView::Init(T &tensor, VkFormat format) +{ + if (format == VK_FORMAT_UNDEFINED) // VK_FORMAT_UNDEFINED means to use the same format as the provided tensor. + { + format = tensor.get_format(); + } + + VkTensorViewCreateInfoARM view_info{VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM}; + view_info.tensor = tensor.get_handle(); + view_info.format = format; + VK_CHECK(vkCreateTensorViewARM(get_device().get_handle(), &view_info, nullptr, &get_handle())); +} + +template void TensorView::Init(Tensor &, VkFormat); +template void TensorView::Init(ExternallyAllocatedTensor &, VkFormat); + +TensorView::~TensorView() +{ + vkDestroyTensorViewARM(get_device().get_handle(), get_handle(), nullptr); +} + +DataGraphPipelineLayout::DataGraphPipelineLayout(vkb::core::DeviceC &device, const std::set &tensor_bindings) : + vkb::core::VulkanResourceC(VK_NULL_HANDLE, &device) +{ + std::vector layout_bindings; + for (uint32_t binding : tensor_bindings) + { + VkDescriptorSetLayoutBinding layout_binding{}; + layout_binding.binding = binding; + layout_binding.descriptorCount = 1; + layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_TENSOR_ARM; + layout_binding.stageFlags = VK_SHADER_STAGE_ALL; // Data graph pipelines don't have shader stages per-se, so VK_SHADER_STAGE_ALL is used. + layout_bindings.push_back(layout_binding); + } + + // Create set layout + VkDescriptorSetLayoutCreateInfo set_layout_create_info{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO}; + set_layout_create_info.bindingCount = static_cast(layout_bindings.size()); + set_layout_create_info.pBindings = layout_bindings.data(); + VK_CHECK(vkCreateDescriptorSetLayout(get_device().get_handle(), &set_layout_create_info, nullptr, &descriptor_set_layout)); + + // Create pipeline layout + VkPipelineLayoutCreateInfo pipeline_layout_create_info{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO}; + pipeline_layout_create_info.setLayoutCount = 1; + pipeline_layout_create_info.pSetLayouts = &descriptor_set_layout; + VK_CHECK(vkCreatePipelineLayout(get_device().get_handle(), &pipeline_layout_create_info, nullptr, &get_handle())); +} + +DataGraphPipelineLayout::~DataGraphPipelineLayout() +{ + vkDestroyDescriptorSetLayout(get_device().get_handle(), descriptor_set_layout, nullptr); + vkDestroyPipelineLayout(get_device().get_handle(), get_handle(), nullptr); +} + +const VkDescriptorSetLayout &DataGraphPipelineLayout::get_descriptor_set_layout() const +{ + return descriptor_set_layout; +} + +DataGraphPipeline::DataGraphPipeline(vkb::core::DeviceC &device, + VkPipelineLayout layout, + VkShaderModule shader_module, + const char *entry_point, + const std::map> &tensor_descriptions, + const std::vector &data_graph_pipeline_constants) : + vkb::core::VulkanResourceC(VK_NULL_HANDLE, &device), shader_module(shader_module) +{ + // Create array of data graph pipeline resource infos (one for each input/output tensor) + std::vector resource_infos; + for (const auto &tensor_descriptions_set : tensor_descriptions) + { + uint32_t set_idx = tensor_descriptions_set.first; + const std::map &tensor_descriptions_this_set = tensor_descriptions_set.second; + + for (const auto &tensor_description_binding : tensor_descriptions_this_set) + { + const VkTensorDescriptionARM *tensor_description = tensor_description_binding.second; + + VkDataGraphPipelineResourceInfoARM resource_info = {VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM}; + resource_info.pNext = tensor_description; + resource_info.descriptorSet = set_idx; + resource_info.binding = tensor_description_binding.first; + resource_infos.push_back(resource_info); + } + } + + // Create data graph pipeline + VkDataGraphPipelineShaderModuleCreateInfoARM pipeline_shader_module_create_info = {VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM}; + pipeline_shader_module_create_info.module = shader_module; + pipeline_shader_module_create_info.pName = entry_point; + + std::vector constants_array(data_graph_pipeline_constants.size()); + if (!data_graph_pipeline_constants.empty()) + { + for (uint32_t i = 0; i < data_graph_pipeline_constants.size(); i++) + { + constants_array[i] = *data_graph_pipeline_constants[i]; + } + + pipeline_shader_module_create_info.constantCount = data_graph_pipeline_constants.size(); + pipeline_shader_module_create_info.pConstants = constants_array.data(); + } + + VkDataGraphPipelineCreateInfoARM pipeline_create_info{VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM}; + pipeline_create_info.pNext = &pipeline_shader_module_create_info; + pipeline_create_info.layout = layout; + pipeline_create_info.resourceInfoCount = resource_infos.size(); + pipeline_create_info.pResourceInfos = resource_infos.data(); + + VK_CHECK(vkCreateDataGraphPipelinesARM(get_device().get_handle(), VK_NULL_HANDLE, VK_NULL_HANDLE, 1, &pipeline_create_info, nullptr, &get_handle())); +} + +DataGraphPipeline::~DataGraphPipeline() +{ + vkDestroyShaderModule(get_device().get_handle(), shader_module, nullptr); + vkDestroyPipeline(get_device().get_handle(), get_handle(), nullptr); +} + +DataGraphPipelineSession::DataGraphPipelineSession(vkb::core::DeviceC &device, + VkPipeline data_graph_pipeline, + VmaAllocationCreateInfo alloc_create_info) : + vkb::allocated::AllocatedC(alloc_create_info, nullptr, &device) +{ + VkDataGraphPipelineSessionCreateInfoARM pipeline_session_create_info = {}; + pipeline_session_create_info.sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM; + pipeline_session_create_info.dataGraphPipeline = data_graph_pipeline; + + VkDataGraphPipelineSessionARM data_graph_pipeline_session = VK_NULL_HANDLE; + VmaAllocationInfo allocation_info{}; + VmaAllocation allocation = VK_NULL_HANDLE; + VK_CHECK(vmaCreateDataGraphPipelineSession( + device.get_handle(), + vkb::allocated::get_memory_allocator(), + &pipeline_session_create_info, + &alloc_create_info, + &data_graph_pipeline_session, + &allocation, + &allocation_info)); + + set_allocation(allocation); + if (allocation_info.size > 0) // Sometimes no memory is needed, which is fine. + { + post_create(allocation_info); + } + set_handle(data_graph_pipeline_session); +} + +DataGraphPipelineSession::~DataGraphPipelineSession() +{ + if (get_handle() != VK_NULL_HANDLE) + { + vmaDestroyDataGraphPipelineSession(get_device().get_handle(), vkb::allocated::get_memory_allocator(), get_handle(), get_allocation()); + clear(); + } +} + +ComputePipelineLayoutWithTensors::ComputePipelineLayoutWithTensors(vkb::core::DeviceC &device, vkb::ShaderModule &shader_module) : + vkb::core::VulkanResourceC(nullptr, &device) +{ + // Create a regular vkb::PipelineLayout to reflect all the regular shader resources except tensors + std::unique_ptr layout_without_tensors = std::make_unique(device, std::vector{&shader_module}); + + // Gather all the binding info that was found + std::map> all_bindings; + for (const std::pair> set_and_resources : layout_without_tensors->get_shader_sets()) + { + uint32_t set_idx = set_and_resources.first; + all_bindings[set_idx] = layout_without_tensors->get_descriptor_set_layout(set_idx).get_bindings(); + } + + // Add tensor resources using reflection of the SPIR-V binary + spirv_cross::CompilerGLSL compiler{shader_module.get_binary()}; + spirv_cross::CompilerGLSL::Options opts = compiler.get_common_options(); + opts.enable_420pack_extension = true; + compiler.set_common_options(opts); + + spirv_cross::SmallVector tensor_resources = compiler.get_shader_resources().tensors; + for (const spirv_cross::Resource &tensor_resource : tensor_resources) + { + uint32_t set_idx = compiler.get_decoration(tensor_resource.id, spv::DecorationDescriptorSet); + uint32_t binding = compiler.get_decoration(tensor_resource.id, spv::DecorationBinding); + + VkDescriptorSetLayoutBinding layout_binding{}; + + layout_binding.binding = binding; + layout_binding.descriptorCount = 1; // Assume this isn't an array (though this support could be added) + layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_TENSOR_ARM; + layout_binding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + + all_bindings[set_idx].push_back(layout_binding); + } + + // Create set layouts now that we have the full set of bindings + std::vector descriptor_set_layouts_array; // As well as storing a std::map of descriptor set layouts, we need a linear array for use in VkPipelineLayoutCreateInfo + for (const std::pair> &set_idx_and_bindings : all_bindings) + { + uint32_t set_idx = set_idx_and_bindings.first; + const std::vector &bindings = set_idx_and_bindings.second; + + VkDescriptorSetLayoutCreateInfo create_info{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO}; + create_info.bindingCount = bindings.size(); + create_info.pBindings = bindings.data(); + + VkDescriptorSetLayout set_layout; + VK_CHECK(vkCreateDescriptorSetLayout(device.get_handle(), &create_info, nullptr, &set_layout)); + + descriptor_set_layouts[set_idx] = set_layout; + descriptor_set_layouts_array.push_back(set_layout); + } + + // Create pipeline layout using these layouts + VkPipelineLayoutCreateInfo create_info{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO}; + create_info.setLayoutCount = descriptor_set_layouts_array.size(); + create_info.pSetLayouts = descriptor_set_layouts_array.data(); + + // Collect all the push constant shader resources + std::vector push_constant_ranges; + for (const auto &push_constant_resource : layout_without_tensors->get_resources(vkb::ShaderResourceType::PushConstant)) + { + push_constant_ranges.push_back({push_constant_resource.stages, push_constant_resource.offset, push_constant_resource.size}); + } + create_info.pushConstantRangeCount = push_constant_ranges.size(); + create_info.pPushConstantRanges = push_constant_ranges.data(); + + // Finally we can create the pipeline layout + VK_CHECK(vkCreatePipelineLayout(device.get_handle(), &create_info, nullptr, &get_handle())); +} + +ComputePipelineLayoutWithTensors::~ComputePipelineLayoutWithTensors() +{ + for (const std::pair &set_idx_and_layout : descriptor_set_layouts) + { + vkDestroyDescriptorSetLayout(get_device().get_handle(), set_idx_and_layout.second, nullptr); + } + vkDestroyPipelineLayout(get_device().get_handle(), get_handle(), nullptr); +} + +const std::map &ComputePipelineLayoutWithTensors::get_descriptor_set_layouts() const +{ + return descriptor_set_layouts; +} + +ComputePipelineWithTensors::ComputePipelineWithTensors(vkb::core::DeviceC &device, VkPipelineLayout layout, vkb::ShaderModule &shader) : + vkb::core::VulkanResourceC(VK_NULL_HANDLE, &device) +{ + // Create shader module + VkShaderModuleCreateInfo module_create_info{}; + module_create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; + module_create_info.codeSize = shader.get_binary().size() * sizeof(uint32_t); + module_create_info.pCode = shader.get_binary().data(); + VK_CHECK(vkCreateShaderModule(device.get_handle(), &module_create_info, NULL, &shader_module)); + + // Create compute pipeline + VkPipelineShaderStageCreateInfo stage{VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO}; + stage.stage = VK_SHADER_STAGE_COMPUTE_BIT; + stage.pName = shader.get_entry_point().c_str(); + stage.module = shader_module; + + VkComputePipelineCreateInfo create_info{VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO}; + create_info.layout = layout; + create_info.stage = stage; + + VK_CHECK(vkCreateComputePipelines(device.get_handle(), VK_NULL_HANDLE, 1, &create_info, nullptr, &get_handle())); +} + +ComputePipelineWithTensors::~ComputePipelineWithTensors() +{ + vkDestroyShaderModule(get_device().get_handle(), shader_module, nullptr); + vkDestroyPipeline(get_device().get_handle(), get_handle(), nullptr); +} + +BlitSubpass::BlitSubpass(vkb::rendering::RenderContextC &renderContext, vkb::core::ImageView *source) : + vkb::rendering::SubpassC(renderContext, vkb::ShaderSource{"tensor_and_data_graph/glsl/fullscreen.vert.spv"}, vkb::ShaderSource{"tensor_and_data_graph/glsl/blit.frag.spv"}), + source(source) +{ +} + +void BlitSubpass::prepare() +{ + vkb::ShaderModule &fullscreen_vert = + get_render_context().get_device().get_resource_cache().request_shader_module(VK_SHADER_STAGE_VERTEX_BIT, vkb::ShaderSource{"tensor_and_data_graph/glsl/fullscreen.vert.spv"}); + vkb::ShaderModule &blit_frag = + get_render_context().get_device().get_resource_cache().request_shader_module(VK_SHADER_STAGE_FRAGMENT_BIT, vkb::ShaderSource{"tensor_and_data_graph/glsl/blit.frag.spv"}); + pipeline_layout = &get_render_context().get_device().get_resource_cache().request_pipeline_layout({&fullscreen_vert, &blit_frag}); + + VkSamplerCreateInfo sampler_create_info{VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO}; + sampler_create_info.minFilter = VK_FILTER_LINEAR; + sampler_create_info.magFilter = VK_FILTER_LINEAR; + sampler_create_info.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER; + sampler_create_info.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER; + sampler_create_info.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER; + sampler = std::make_unique(get_render_context().get_device(), sampler_create_info); +} + +void BlitSubpass::set_source(vkb::core::ImageView *source) +{ + this->source = source; +} + +void BlitSubpass::draw(vkb::core::CommandBufferC &command_buffer) +{ + vkb::RasterizationState rasterization_state = {}; + rasterization_state.cull_mode = VK_CULL_MODE_NONE; + command_buffer.set_rasterization_state(rasterization_state); + + vkb::DepthStencilState depth_stencil_state = {}; + depth_stencil_state.depth_test_enable = VK_FALSE; + command_buffer.set_depth_stencil_state(depth_stencil_state); + + command_buffer.bind_pipeline_layout(*pipeline_layout); + command_buffer.bind_image(*source, *sampler, 0, 0, 0); + command_buffer.draw(3, 1, 0, 0); +} diff --git a/samples/extensions/tensor_and_data_graph/tensor_and_data_graph_common.h b/samples/extensions/tensor_and_data_graph/tensor_and_data_graph_common.h new file mode 100644 index 000000000..e339347fa --- /dev/null +++ b/samples/extensions/tensor_and_data_graph/tensor_and_data_graph_common.h @@ -0,0 +1,326 @@ +/* Copyright (c) 2024-2025, Arm Limited and Contributors + * + * SPDX-License-Identifier: Apache-2.0 + * + * 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. + */ + +/* + * @file Contains helper functions and types for working with tensors and data graph pipelines. + * Many of these are analogous with the Image and Buffer equivalents in the sample framework. + */ + +#pragma once + +#include +#include +#include +#include +#include + +/** + * Simple wrapper around an array of elements of type T which interprets it as a multidimensional array, + * allowing convenient access to elements using a multidimensional index. + */ +template +struct MultidimensionalArrayView +{ + T *data; + std::vector dimensions; + + MultidimensionalArrayView(T *data, const std::vector &dimensions) : + data(data), dimensions(dimensions) + { + } + + T &operator[](std::initializer_list indices) + { + if (indices.size() != dimensions.size()) + { + throw std::runtime_error("Number of indices must match number of dimensions"); + } + size_t index = 0; + size_t multiplier = 1; + // Calculate the index based on the provided indices and dimensions + for (int i = dimensions.size() - 1; i >= 0; --i) + { + index += *(indices.begin() + i) * multiplier; + multiplier *= dimensions[i]; + } + return data[index]; + } +}; + +/* + ** @brief Helper function to write a series of image and tensor bindings to a descriptor set. Does not support descriptor arrays. + */ +void write_descriptor_set(VkDevice device, + VkDescriptorSet set, + const std::map &image_bindings, + const std::map &tensor_bindings); + +/* + * @brief Creates a Tensor resource and backs it with memory. Analogous to vmaCreateImage/Buffer. + * @detail When finished, destroy the tensor and its memory using vmaDestroyTensor. + */ +VkResult vmaCreateTensor(VkDevice device, + VmaAllocator allocator, + const VkTensorCreateInfoARM *pTensorCreateInfo, + const VmaAllocationCreateInfo *pAllocationCreateInfo, + VkTensorARM *pTensor, + VmaAllocation *pAllocation, + VmaAllocationInfo *pAllocationInfo); + +/* + ** @brief Destroys a Tensor resource and its backing memory, which were created from vmaCreateTensor. Analogous to vmaDestroyImage/Buffer. + */ +void vmaDestroyTensor(VkDevice device, + VmaAllocator allocator, + VkTensorARM tensor, + VmaAllocation allocation); + +/* + * @brief Creates a VkDataGraphPipelineSessionARM resource and backs it with memory. Analogous to vmaCreateImage/Buffer. + * @detail When finished, destroy the session and its memory using vmaDestroyDataGraphPipelineSession. + */ +VkResult vmaCreateDataGraphPipelineSession(VkDevice device, + VmaAllocator allocator, + const VkDataGraphPipelineSessionCreateInfoARM *pDataGraphPipelineSessionCreateInfo, + const VmaAllocationCreateInfo *pAllocationCreateInfo, + VkDataGraphPipelineSessionARM *pDataGraphPipelineSession, + VmaAllocation *pAllocation, + VmaAllocationInfo *pAllocationInfo); + +/* + ** @brief Destroys a DataGraphPipelineSession resource and its backing memory, which were created from vmaCreateDataGraphPipelineSession. Analogous to vmaDestroyImage/Buffer. + */ +void vmaDestroyDataGraphPipelineSession(VkDevice device, + VmaAllocator allocator, + VkDataGraphPipelineSessionARM session, + VmaAllocation allocation); + +/* + * @brief Helper class to describe a Tensor resource that is to be created (see Tensor constructor below). Analogous to vkb::ImageBuilder/BufferBuilder. + */ +class TensorBuilder : public vkb::allocated::BuilderBaseC +{ + public: + TensorBuilder(std::vector in_dimensions); + + TensorBuilder &with_format(VkFormat format); + TensorBuilder &with_tiling(VkTensorTilingARM tiling); + TensorBuilder &with_usage(VkTensorUsageFlagsARM usage); + + private: + // VkTensorCreateInfoARM (stored in the base class) has a pointer to a VkTensorDescriptionARM, + // so we need to store that struct separately so that it outlives the pointer. + VkTensorDescriptionARM description; + // The description points to a dimensions array, so we need to store that array separately so that it outlives the pointer. + std::vector dimensions; +}; + +/* + * @brief Common descriptor class used by Tensor and ExternallyAllocatedTensor. + */ +class TensorDescriptor +{ + public: + TensorDescriptor(const TensorBuilder &builder); + ~TensorDescriptor() = default; + + const VkTensorCreateInfoARM &get_create_info() const; + + const VkTensorDescriptionARM &get_description() const; + + private: + VkTensorCreateInfoARM create_info; + // create_info has a pointer to a VkTensorDescriptionARM, so we need to store that struct separately so that it outlives the pointer. + VkTensorDescriptionARM description; + // The description points to a dimensions array, so we need to store that array separately so that it outlives the pointer. + std::vector dimensions; +}; + +/* + * @brief Helper class to create and manage the lifetime of a VkTensorARM resource. Analogous to vkb::Image/Buffer. + */ +class Tensor : public vkb::allocated::AllocatedC +{ + public: + Tensor(vkb::core::DeviceC &device, TensorBuilder const &builder); + ~Tensor(); + + const VkTensorDescriptionARM &get_description() const; + + VkFormat get_format() const; + + private: + TensorDescriptor descriptor; +}; + +/* + * @brief Helper class to create and manage the lifetime of a VkTensorARM resource, but does not allocate + * any its own memory. Memory must be provided on construction and is useful for creating tensors that alias existing memory. + */ +class ExternallyAllocatedTensor : public vkb::core::VulkanResourceC +{ + public: + ExternallyAllocatedTensor(vkb::core::DeviceC &device, TensorBuilder const &builder, VkDeviceMemory existing_memory, + VkDeviceSize existing_memory_offset); + ~ExternallyAllocatedTensor(); + + const VkTensorDescriptionARM &get_description() const; + + VkFormat get_format() const; + + private: + TensorDescriptor descriptor; +}; + +/* + * @brief Helper class to create and manage the lifetime of a VkTensorARM resource. Analogous to vkb::ImageView/BufferView. + */ +class TensorView : public vkb::core::VulkanResourceC +{ + public: + TensorView(Tensor &tensor, VkFormat format = VK_FORMAT_UNDEFINED); // VK_FORMAT_UNDEFINED means to use the same format as the provided tensor. + TensorView(ExternallyAllocatedTensor &tensor, VkFormat format = VK_FORMAT_UNDEFINED); // VK_FORMAT_UNDEFINED means to use the same format as the provided tensor. + ~TensorView(); + + private: + template + void Init(T &tensor, VkFormat format); +}; + +/* + * @brief Helper struct to hold the resources needed for a constant tensor. + */ +template +struct PipelineConstantTensor +{ + std::vector dimensions; + std::vector constant_data; + VkTensorDescriptionARM tensor_description{}; + VkDataGraphPipelineConstantARM pipeline_constant{}; +}; + +/* + * @brief Helper class to create and manage the lifetime of a VkPipelineLayout resource for a Data Graph Pipeline. Analogous to vkb::PipelineLayout. + * @detail This class only supports a single descriptor set, but the underyling APIs do support multiple desriptor sets. + We also create and manage this corresponding VkDescriptorSetLayout. + Typically, layout creation would be done using reflection on the assembled SPIR-V shader code, however spirv-cross does not yet support + reflection on data graph shaders. Therefore the caller must provide the layout themselves, but thankfully this is quite minimal (we just need to know + the binding points for tensors). + */ +class DataGraphPipelineLayout : public vkb::core::VulkanResourceC +{ + public: + /* + * @brief Creates a DataGraphPipelineLayout. Assumes all tensor bindings are in the first descriptor set. + * @param tensor_bindings The binding numbers for every tensor, which are assumed to be in the first descriptor set. + */ + DataGraphPipelineLayout(vkb::core::DeviceC &device, const std::set &tensor_bindings); + ~DataGraphPipelineLayout(); + + const VkDescriptorSetLayout &get_descriptor_set_layout() const; + + private: + VkDescriptorSetLayout descriptor_set_layout = VK_NULL_HANDLE; +}; + +/* + * @brief Helper class to create and manage the lifetime of a VkPipeline resource for a Data Graph Pipeline. Similar to vkb::ComputePipeline. + */ +class DataGraphPipeline : public vkb::core::VulkanResourceC +{ + public: + /* + * @brief Creates a DataGraphPipeline. + * @param tensor_descriptions Descriptions (shape, format, etc.) for each tensor that will be bound to this pipeline. + * The first key in the map is the set number and the second key is the binding number. + */ + DataGraphPipeline(vkb::core::DeviceC &device, + VkPipelineLayout layout, + VkShaderModule shader_module, + const char *entry_point, + const std::map> &tensor_descriptions, + const std::vector &data_graph_pipeline_constants = std::vector()); + ~DataGraphPipeline(); + + private: + VkShaderModule shader_module = VK_NULL_HANDLE; +}; + +/* + * @brief Helper class to create and manage the lifetime of a VkDataGraphPipelineSessionARM resource. + * @detail Unlike compute and graphics pipelines, data graph pipelines require additional state to be stored (e.g. for intermediate results). This is stored + * separately to the pipeline itself in a new 'pipeline session' resource. This requires memory to be allocated and bound to it (similar to a buffer). + */ +class DataGraphPipelineSession : public vkb::allocated::AllocatedC +{ + public: + DataGraphPipelineSession(vkb::core::DeviceC &device, VkPipeline data_graph_pipeline, VmaAllocationCreateInfo alloc_create_info); + ~DataGraphPipelineSession(); +}; + +/* + * @brief Helper class to create and manage the lifetime of a VkPipelineLayout resource for a Compute Pipeline. Similar to vkb::PipelineLayout, but supports Tensor resources. + * @detail The sample framework's vkb::PipelineLayout class doesn't understand Tensor resources, so can't be used for compute shaders that use tensors. + * This class is a modified copy of vkb::PipelineLayout that does support tensors, albeit with less other features. + */ +class ComputePipelineLayoutWithTensors : public vkb::core::VulkanResourceC +{ + public: + ComputePipelineLayoutWithTensors(vkb::core::DeviceC &device, vkb::ShaderModule &shader_module); + ~ComputePipelineLayoutWithTensors(); + + const std::map &get_descriptor_set_layouts() const; + + private: + std::map descriptor_set_layouts; +}; + +/* + * @brief Helper class to create and manage the lifetime of a VkPipeline resource for a Compute Pipeline. Similar to vkb::ComputePipeline, but supports Tensor resources. + * @detail The sample framework's vkb::ComputePipeline class (and its dependencies) don't understand Tensor resources, so can't be used for compute shaders that use tensors. + * This class is a modified copy of vkb::ComputePipeline that does support tensors, albeit with less other features. + * We can't use the vkb::PipelineState as that doesn't support tensors, so instead take the VkPipelineLayout and vkb::ShaderModule directly. + */ +class ComputePipelineWithTensors : public vkb::core::VulkanResourceC +{ + public: + ComputePipelineWithTensors(vkb::core::DeviceC &device, VkPipelineLayout layout, vkb::ShaderModule &shader); + ~ComputePipelineWithTensors(); + + private: + VkShaderModule shader_module = VK_NULL_HANDLE; +}; + +/* + * @brief Simple subpass for use with vkb::RenderPipeline, which blits an image to the render target (stretching to fit). + */ +class BlitSubpass : public vkb::rendering::SubpassC +{ + public: + BlitSubpass(vkb::rendering::RenderContextC &renderContext, vkb::core::ImageView *source = nullptr); + + void prepare() override; + + void set_source(vkb::core::ImageView *source); + + void draw(vkb::core::CommandBufferC &command_buffer) override; + + private: + vkb::PipelineLayout *pipeline_layout = nullptr; + vkb::core::ImageView *source = nullptr; + std::unique_ptr sampler = nullptr; +}; diff --git a/samples/extensions/tensor_and_data_graph/verify_layers.png b/samples/extensions/tensor_and_data_graph/verify_layers.png new file mode 100644 index 000000000..333320790 Binary files /dev/null and b/samples/extensions/tensor_and_data_graph/verify_layers.png differ diff --git a/samples/tooling/profiles/vulkan_profiles.hpp b/samples/tooling/profiles/vulkan_profiles.hpp index b8658164e..aab81bcfe 100644 --- a/samples/tooling/profiles/vulkan_profiles.hpp +++ b/samples/tooling/profiles/vulkan_profiles.hpp @@ -1,7 +1,7 @@ /* - * Copyright (C) 2021-2024 Valve Corporation - * Copyright (C) 2021-2024 LunarG, Inc. + * Copyright (C) 2021-2025 Valve Corporation + * Copyright (C) 2021-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. @@ -18,7 +18,6 @@ * This file is ***GENERATED***. Do Not Edit. * See scripts/gen_profiles_solution.py for modifications. */ -/* clang-format off */ #pragma once @@ -26,250 +25,423 @@ #include -#include +#include +#include +#include #include +#include +#include #include #include -#include -#include -#include +#include +#include #include #include -#include -#include -#include -#if defined(VK_VERSION_1_1) && \ +#if defined(VK_VERSION_1_1) && \ defined(VK_ANDROID_external_memory_android_hardware_buffer) && \ - defined(VK_EXT_queue_family_foreign) && \ - defined(VK_EXT_swapchain_colorspace) && \ - defined(VK_GOOGLE_display_timing) && \ - defined(VK_KHR_android_surface) && \ - defined(VK_KHR_create_renderpass2) && \ - defined(VK_KHR_dedicated_allocation) && \ - defined(VK_KHR_descriptor_update_template) && \ - defined(VK_KHR_driver_properties) && \ - defined(VK_KHR_external_fence) && \ - defined(VK_KHR_external_fence_capabilities) && \ - defined(VK_KHR_external_fence_fd) && \ - defined(VK_KHR_external_memory) && \ - defined(VK_KHR_external_memory_capabilities) && \ - defined(VK_KHR_external_semaphore) && \ - defined(VK_KHR_external_semaphore_capabilities) && \ - defined(VK_KHR_external_semaphore_fd) && \ - defined(VK_KHR_get_memory_requirements2) && \ - defined(VK_KHR_get_physical_device_properties2) && \ - defined(VK_KHR_get_surface_capabilities2) && \ - defined(VK_KHR_incremental_present) && \ - defined(VK_KHR_maintenance1) && \ - defined(VK_KHR_sampler_mirror_clamp_to_edge) && \ - defined(VK_KHR_storage_buffer_storage_class) && \ - defined(VK_KHR_surface) && \ - defined(VK_KHR_swapchain) && \ + defined(VK_EXT_queue_family_foreign) && \ + defined(VK_EXT_swapchain_colorspace) && \ + defined(VK_GOOGLE_display_timing) && \ + defined(VK_KHR_android_surface) && \ + defined(VK_KHR_create_renderpass2) && \ + defined(VK_KHR_dedicated_allocation) && \ + defined(VK_KHR_descriptor_update_template) && \ + defined(VK_KHR_driver_properties) && \ + defined(VK_KHR_external_fence) && \ + defined(VK_KHR_external_fence_capabilities) && \ + defined(VK_KHR_external_fence_fd) && \ + defined(VK_KHR_external_memory) && \ + defined(VK_KHR_external_memory_capabilities) && \ + defined(VK_KHR_external_semaphore) && \ + defined(VK_KHR_external_semaphore_capabilities) && \ + defined(VK_KHR_external_semaphore_fd) && \ + defined(VK_KHR_get_memory_requirements2) && \ + defined(VK_KHR_get_physical_device_properties2) && \ + defined(VK_KHR_get_surface_capabilities2) && \ + defined(VK_KHR_incremental_present) && \ + defined(VK_KHR_maintenance1) && \ + defined(VK_KHR_sampler_mirror_clamp_to_edge) && \ + defined(VK_KHR_storage_buffer_storage_class) && \ + defined(VK_KHR_surface) && \ + defined(VK_KHR_swapchain) && \ defined(VK_KHR_variable_pointers) -#define VP_ANDROID_baseline_2022 1 -#define VP_ANDROID_BASELINE_2022_NAME "VP_ANDROID_baseline_2022" -#define VP_ANDROID_BASELINE_2022_SPEC_VERSION 2 -#define VP_ANDROID_BASELINE_2022_MIN_API_VERSION VK_MAKE_VERSION(1, 1, 106) +# define VP_ANDROID_baseline_2022 1 +# define VP_ANDROID_BASELINE_2022_NAME "VP_ANDROID_baseline_2022" +# define VP_ANDROID_BASELINE_2022_SPEC_VERSION 2 +# define VP_ANDROID_BASELINE_2022_MIN_API_VERSION VK_MAKE_VERSION(1, 1, 106) #endif -#if defined(VK_VERSION_1_3) && \ - defined(VP_ANDROID_baseline_2022) && \ - defined(VK_ANDROID_external_format_resolve) && \ - defined(VK_EXT_4444_formats) && \ - defined(VK_EXT_custom_border_color) && \ - defined(VK_EXT_device_memory_report) && \ +#if defined(VK_VERSION_1_3) && \ + defined(VP_ANDROID_baseline_2022) && \ + defined(VK_ANDROID_external_format_resolve) && \ + defined(VK_EXT_4444_formats) && \ + defined(VK_EXT_custom_border_color) && \ + defined(VK_EXT_device_memory_report) && \ defined(VK_EXT_external_memory_acquire_unmodified) && \ - defined(VK_EXT_index_type_uint8) && \ - defined(VK_EXT_line_rasterization) && \ - defined(VK_EXT_load_store_op_none) && \ - defined(VK_EXT_primitive_topology_list_restart) && \ - defined(VK_EXT_primitives_generated_query) && \ - defined(VK_EXT_provoking_vertex) && \ - defined(VK_EXT_scalar_block_layout) && \ - defined(VK_EXT_surface_maintenance1) && \ - defined(VK_EXT_swapchain_maintenance1) && \ - defined(VK_GOOGLE_surfaceless_query) && \ - defined(VK_IMG_relaxed_line_rasterization) && \ - defined(VK_KHR_16bit_storage) && \ - defined(VK_KHR_maintenance5) && \ - defined(VK_KHR_shader_float16_int8) && \ + defined(VK_EXT_index_type_uint8) && \ + defined(VK_EXT_line_rasterization) && \ + defined(VK_EXT_load_store_op_none) && \ + defined(VK_EXT_primitive_topology_list_restart) && \ + defined(VK_EXT_primitives_generated_query) && \ + defined(VK_EXT_provoking_vertex) && \ + defined(VK_EXT_scalar_block_layout) && \ + defined(VK_EXT_surface_maintenance1) && \ + defined(VK_EXT_swapchain_maintenance1) && \ + defined(VK_GOOGLE_surfaceless_query) && \ + defined(VK_IMG_relaxed_line_rasterization) && \ + defined(VK_KHR_16bit_storage) && \ + defined(VK_KHR_maintenance5) && \ + defined(VK_KHR_shader_float16_int8) && \ defined(VK_KHR_vertex_attribute_divisor) -#define VP_ANDROID_15_minimums 1 -#define VP_ANDROID_15_MINIMUMS_NAME "VP_ANDROID_15_minimums" -#define VP_ANDROID_15_MINIMUMS_SPEC_VERSION 1 -#define VP_ANDROID_15_MINIMUMS_MIN_API_VERSION VK_MAKE_VERSION(1, 3, 273) +# define VP_ANDROID_15_minimums 1 +# define VP_ANDROID_15_MINIMUMS_NAME "VP_ANDROID_15_minimums" +# define VP_ANDROID_15_MINIMUMS_SPEC_VERSION 1 +# define VP_ANDROID_15_MINIMUMS_MIN_API_VERSION VK_MAKE_VERSION(1, 3, 273) #endif -#if defined(VK_VERSION_1_3) && \ - defined(VP_ANDROID_15_minimums) && \ - defined(VP_ANDROID_baseline_2022) && \ - defined(VK_EXT_host_image_copy) && \ - defined(VK_EXT_image_2d_view_of_3d) && \ +#if defined(VK_VERSION_1_3) && \ + defined(VP_ANDROID_15_minimums) && \ + defined(VP_ANDROID_baseline_2022) && \ + defined(VK_EXT_host_image_copy) && \ + defined(VK_EXT_image_2d_view_of_3d) && \ defined(VK_EXT_multisampled_render_to_single_sampled) && \ - defined(VK_EXT_pipeline_protected_access) && \ - defined(VK_EXT_pipeline_robustness) && \ - defined(VK_EXT_shader_stencil_export) && \ - defined(VK_EXT_transform_feedback) && \ - defined(VK_KHR_8bit_storage) && \ - defined(VK_KHR_global_priority) && \ - defined(VK_KHR_load_store_op_none) && \ - defined(VK_KHR_maintenance6) && \ - defined(VK_KHR_map_memory2) && \ - defined(VK_KHR_push_descriptor) && \ - defined(VK_KHR_shader_expect_assume) && \ - defined(VK_KHR_shader_float_controls2) && \ - defined(VK_KHR_shader_maximal_reconvergence) && \ - defined(VK_KHR_shader_subgroup_rotate) && \ - defined(VK_KHR_shader_subgroup_uniform_control_flow) && \ + defined(VK_EXT_pipeline_protected_access) && \ + defined(VK_EXT_pipeline_robustness) && \ + defined(VK_EXT_shader_stencil_export) && \ + defined(VK_EXT_transform_feedback) && \ + defined(VK_KHR_8bit_storage) && \ + defined(VK_KHR_load_store_op_none) && \ + defined(VK_KHR_maintenance6) && \ + defined(VK_KHR_map_memory2) && \ + defined(VK_KHR_shader_expect_assume) && \ + defined(VK_KHR_shader_float_controls2) && \ + defined(VK_KHR_shader_maximal_reconvergence) && \ + defined(VK_KHR_shader_subgroup_rotate) && \ + defined(VK_KHR_shader_subgroup_uniform_control_flow) && \ defined(VK_KHR_swapchain_mutable_format) -#define VP_ANDROID_16_minimums 1 -#define VP_ANDROID_16_MINIMUMS_NAME "VP_ANDROID_16_minimums" -#define VP_ANDROID_16_MINIMUMS_SPEC_VERSION 1 -#define VP_ANDROID_16_MINIMUMS_MIN_API_VERSION VK_MAKE_VERSION(1, 3, 276) +# define VP_ANDROID_16_minimums 1 +# define VP_ANDROID_16_MINIMUMS_NAME "VP_ANDROID_16_minimums" +# define VP_ANDROID_16_MINIMUMS_SPEC_VERSION 1 +# define VP_ANDROID_16_MINIMUMS_MIN_API_VERSION VK_MAKE_VERSION(1, 3, 276) #endif -#if defined(VK_VERSION_1_0) && \ - defined(VK_EXT_swapchain_colorspace) && \ - defined(VK_GOOGLE_display_timing) && \ - defined(VK_KHR_android_surface) && \ - defined(VK_KHR_dedicated_allocation) && \ - defined(VK_KHR_descriptor_update_template) && \ - defined(VK_KHR_external_fence) && \ - defined(VK_KHR_external_fence_capabilities) && \ - defined(VK_KHR_external_fence_fd) && \ - defined(VK_KHR_external_memory) && \ - defined(VK_KHR_external_memory_capabilities) && \ - defined(VK_KHR_external_semaphore) && \ +#if defined(VK_VERSION_1_0) && \ + defined(VK_EXT_swapchain_colorspace) && \ + defined(VK_GOOGLE_display_timing) && \ + defined(VK_KHR_android_surface) && \ + defined(VK_KHR_dedicated_allocation) && \ + defined(VK_KHR_descriptor_update_template) && \ + defined(VK_KHR_external_fence) && \ + defined(VK_KHR_external_fence_capabilities) && \ + defined(VK_KHR_external_fence_fd) && \ + defined(VK_KHR_external_memory) && \ + defined(VK_KHR_external_memory_capabilities) && \ + defined(VK_KHR_external_semaphore) && \ defined(VK_KHR_external_semaphore_capabilities) && \ - defined(VK_KHR_external_semaphore_fd) && \ - defined(VK_KHR_get_memory_requirements2) && \ + defined(VK_KHR_external_semaphore_fd) && \ + defined(VK_KHR_get_memory_requirements2) && \ defined(VK_KHR_get_physical_device_properties2) && \ - defined(VK_KHR_get_surface_capabilities2) && \ - defined(VK_KHR_incremental_present) && \ - defined(VK_KHR_maintenance1) && \ - defined(VK_KHR_storage_buffer_storage_class) && \ - defined(VK_KHR_surface) && \ - defined(VK_KHR_swapchain) && \ + defined(VK_KHR_get_surface_capabilities2) && \ + defined(VK_KHR_incremental_present) && \ + defined(VK_KHR_maintenance1) && \ + defined(VK_KHR_storage_buffer_storage_class) && \ + defined(VK_KHR_surface) && \ + defined(VK_KHR_swapchain) && \ defined(VK_KHR_variable_pointers) -#define VP_ANDROID_baseline_2021 1 -#define VP_ANDROID_BASELINE_2021_NAME "VP_ANDROID_baseline_2021" -#define VP_ANDROID_BASELINE_2021_SPEC_VERSION 3 -#define VP_ANDROID_BASELINE_2021_MIN_API_VERSION VK_MAKE_VERSION(1, 0, 68) +# define VP_ANDROID_baseline_2021 1 +# define VP_ANDROID_BASELINE_2021_NAME "VP_ANDROID_baseline_2021" +# define VP_ANDROID_BASELINE_2021_SPEC_VERSION 3 +# define VP_ANDROID_BASELINE_2021_MIN_API_VERSION VK_MAKE_VERSION(1, 0, 68) #endif #if defined(VK_VERSION_1_3) && \ defined(VK_KHR_global_priority) -#define VP_KHR_roadmap_2022 1 -#define VP_KHR_ROADMAP_2022_NAME "VP_KHR_roadmap_2022" -#define VP_KHR_ROADMAP_2022_SPEC_VERSION 1 -#define VP_KHR_ROADMAP_2022_MIN_API_VERSION VK_MAKE_VERSION(1, 3, 204) +# define VP_KHR_roadmap_2022 1 +# define VP_KHR_ROADMAP_2022_NAME "VP_KHR_roadmap_2022" +# define VP_KHR_ROADMAP_2022_SPEC_VERSION 1 +# define VP_KHR_ROADMAP_2022_MIN_API_VERSION VK_MAKE_VERSION(1, 3, 204) #endif -#if defined(VK_VERSION_1_3) && \ - defined(VP_KHR_roadmap_2022) && \ - defined(VK_KHR_dynamic_rendering_local_read) && \ - defined(VK_KHR_index_type_uint8) && \ - defined(VK_KHR_line_rasterization) && \ - defined(VK_KHR_load_store_op_none) && \ - defined(VK_KHR_maintenance5) && \ - defined(VK_KHR_map_memory2) && \ - defined(VK_KHR_push_descriptor) && \ - defined(VK_KHR_shader_expect_assume) && \ - defined(VK_KHR_shader_float_controls2) && \ - defined(VK_KHR_shader_maximal_reconvergence) && \ - defined(VK_KHR_shader_quad_control) && \ - defined(VK_KHR_shader_subgroup_rotate) && \ +#if defined(VK_VERSION_1_3) && \ + defined(VP_KHR_roadmap_2022) && \ + defined(VK_KHR_dynamic_rendering_local_read) && \ + defined(VK_KHR_index_type_uint8) && \ + defined(VK_KHR_line_rasterization) && \ + defined(VK_KHR_load_store_op_none) && \ + defined(VK_KHR_maintenance5) && \ + defined(VK_KHR_map_memory2) && \ + defined(VK_KHR_push_descriptor) && \ + defined(VK_KHR_shader_expect_assume) && \ + defined(VK_KHR_shader_float_controls2) && \ + defined(VK_KHR_shader_maximal_reconvergence) && \ + defined(VK_KHR_shader_quad_control) && \ + defined(VK_KHR_shader_subgroup_rotate) && \ defined(VK_KHR_shader_subgroup_uniform_control_flow) && \ defined(VK_KHR_vertex_attribute_divisor) -#define VP_KHR_roadmap_2024 1 -#define VP_KHR_ROADMAP_2024_NAME "VP_KHR_roadmap_2024" -#define VP_KHR_ROADMAP_2024_SPEC_VERSION 1 -#define VP_KHR_ROADMAP_2024_MIN_API_VERSION VK_MAKE_VERSION(1, 3, 276) +# define VP_KHR_roadmap_2024 1 +# define VP_KHR_ROADMAP_2024_NAME "VP_KHR_roadmap_2024" +# define VP_KHR_ROADMAP_2024_SPEC_VERSION 1 +# define VP_KHR_ROADMAP_2024_MIN_API_VERSION VK_MAKE_VERSION(1, 3, 276) +#endif + +#if defined(VK_VERSION_1_1) && \ + defined(VK_EXT_descriptor_indexing) && \ + defined(VK_EXT_host_query_reset) && \ + defined(VK_EXT_inline_uniform_block) && \ + defined(VK_EXT_memory_budget) && \ + defined(VK_EXT_robustness2) && \ + defined(VK_EXT_scalar_block_layout) && \ + defined(VK_EXT_subgroup_size_control) && \ + defined(VK_EXT_texel_buffer_alignment) && \ + defined(VK_EXT_vertex_attribute_divisor) && \ + defined(VK_KHR_16bit_storage) && \ + defined(VK_KHR_8bit_storage) && \ + defined(VK_KHR_bind_memory2) && \ + defined(VK_KHR_create_renderpass2) && \ + defined(VK_KHR_dedicated_allocation) && \ + defined(VK_KHR_depth_stencil_resolve) && \ + defined(VK_KHR_descriptor_update_template) && \ + defined(VK_KHR_device_group) && \ + defined(VK_KHR_driver_properties) && \ + defined(VK_KHR_external_fence) && \ + defined(VK_KHR_external_memory) && \ + defined(VK_KHR_external_semaphore) && \ + defined(VK_KHR_get_memory_requirements2) && \ + defined(VK_KHR_image_format_list) && \ + defined(VK_KHR_maintenance1) && \ + defined(VK_KHR_maintenance2) && \ + defined(VK_KHR_maintenance3) && \ + defined(VK_KHR_multiview) && \ + defined(VK_KHR_relaxed_block_layout) && \ + defined(VK_KHR_sampler_mirror_clamp_to_edge) && \ + defined(VK_KHR_shader_draw_parameters) && \ + defined(VK_KHR_shader_float16_int8) && \ + defined(VK_KHR_storage_buffer_storage_class) && \ + defined(VK_KHR_swapchain) && \ + defined(VK_KHR_swapchain_mutable_format) && \ + defined(VK_KHR_timeline_semaphore) && \ + defined(VK_KHR_uniform_buffer_standard_layout) && \ + defined(VK_KHR_variable_pointers) +# define VP_LUNARG_desktop_baseline_2022 1 +# define VP_LUNARG_DESKTOP_BASELINE_2022_NAME "VP_LUNARG_desktop_baseline_2022" +# define VP_LUNARG_DESKTOP_BASELINE_2022_SPEC_VERSION 2 +# define VP_LUNARG_DESKTOP_BASELINE_2022_MIN_API_VERSION VK_MAKE_VERSION(1, 1, 139) +#endif + +#if defined(VK_VERSION_1_2) && \ + defined(VK_EXT_descriptor_indexing) && \ + defined(VK_EXT_host_query_reset) && \ + defined(VK_EXT_image_robustness) && \ + defined(VK_EXT_inline_uniform_block) && \ + defined(VK_EXT_memory_budget) && \ + defined(VK_EXT_robustness2) && \ + defined(VK_EXT_subgroup_size_control) && \ + defined(VK_EXT_texel_buffer_alignment) && \ + defined(VK_EXT_vertex_attribute_divisor) && \ + defined(VK_KHR_16bit_storage) && \ + defined(VK_KHR_8bit_storage) && \ + defined(VK_KHR_bind_memory2) && \ + defined(VK_KHR_create_renderpass2) && \ + defined(VK_KHR_dedicated_allocation) && \ + defined(VK_KHR_depth_stencil_resolve) && \ + defined(VK_KHR_descriptor_update_template) && \ + defined(VK_KHR_device_group) && \ + defined(VK_KHR_driver_properties) && \ + defined(VK_KHR_external_fence) && \ + defined(VK_KHR_external_memory) && \ + defined(VK_KHR_external_semaphore) && \ + defined(VK_KHR_get_memory_requirements2) && \ + defined(VK_KHR_image_format_list) && \ + defined(VK_KHR_imageless_framebuffer) && \ + defined(VK_KHR_maintenance1) && \ + defined(VK_KHR_maintenance2) && \ + defined(VK_KHR_maintenance3) && \ + defined(VK_KHR_multiview) && \ + defined(VK_KHR_relaxed_block_layout) && \ + defined(VK_KHR_sampler_mirror_clamp_to_edge) && \ + defined(VK_KHR_separate_depth_stencil_layouts) && \ + defined(VK_KHR_shader_draw_parameters) && \ + defined(VK_KHR_shader_float16_int8) && \ + defined(VK_KHR_shader_float_controls) && \ + defined(VK_KHR_spirv_1_4) && \ + defined(VK_KHR_storage_buffer_storage_class) && \ + defined(VK_KHR_swapchain) && \ + defined(VK_KHR_swapchain_mutable_format) && \ + defined(VK_KHR_timeline_semaphore) && \ + defined(VK_KHR_uniform_buffer_standard_layout) && \ + defined(VK_KHR_variable_pointers) +# define VP_LUNARG_desktop_baseline_2023 1 +# define VP_LUNARG_DESKTOP_BASELINE_2023_NAME "VP_LUNARG_desktop_baseline_2023" +# define VP_LUNARG_DESKTOP_BASELINE_2023_SPEC_VERSION 2 +# define VP_LUNARG_DESKTOP_BASELINE_2023_MIN_API_VERSION VK_MAKE_VERSION(1, 2, 148) +#endif + +#if defined(VK_VERSION_1_2) && \ + defined(VK_EXT_4444_formats) && \ + defined(VK_EXT_calibrated_timestamps) && \ + defined(VK_EXT_descriptor_indexing) && \ + defined(VK_EXT_extended_dynamic_state) && \ + defined(VK_EXT_extended_dynamic_state2) && \ + defined(VK_EXT_external_memory_host) && \ + defined(VK_EXT_host_query_reset) && \ + defined(VK_EXT_image_robustness) && \ + defined(VK_EXT_inline_uniform_block) && \ + defined(VK_EXT_memory_budget) && \ + defined(VK_EXT_pipeline_creation_cache_control) && \ + defined(VK_EXT_pipeline_creation_feedback) && \ + defined(VK_EXT_private_data) && \ + defined(VK_EXT_robustness2) && \ + defined(VK_EXT_scalar_block_layout) && \ + defined(VK_EXT_separate_stencil_usage) && \ + defined(VK_EXT_shader_atomic_float) && \ + defined(VK_EXT_shader_demote_to_helper_invocation) && \ + defined(VK_EXT_shader_subgroup_ballot) && \ + defined(VK_EXT_shader_subgroup_vote) && \ + defined(VK_EXT_shader_viewport_index_layer) && \ + defined(VK_EXT_subgroup_size_control) && \ + defined(VK_EXT_texel_buffer_alignment) && \ + defined(VK_EXT_vertex_attribute_divisor) && \ + defined(VK_KHR_16bit_storage) && \ + defined(VK_KHR_8bit_storage) && \ + defined(VK_KHR_bind_memory2) && \ + defined(VK_KHR_buffer_device_address) && \ + defined(VK_KHR_copy_commands2) && \ + defined(VK_KHR_create_renderpass2) && \ + defined(VK_KHR_dedicated_allocation) && \ + defined(VK_KHR_depth_stencil_resolve) && \ + defined(VK_KHR_descriptor_update_template) && \ + defined(VK_KHR_device_group) && \ + defined(VK_KHR_driver_properties) && \ + defined(VK_KHR_dynamic_rendering) && \ + defined(VK_KHR_external_fence) && \ + defined(VK_KHR_external_memory) && \ + defined(VK_KHR_external_semaphore) && \ + defined(VK_KHR_format_feature_flags2) && \ + defined(VK_KHR_get_memory_requirements2) && \ + defined(VK_KHR_image_format_list) && \ + defined(VK_KHR_imageless_framebuffer) && \ + defined(VK_KHR_maintenance1) && \ + defined(VK_KHR_maintenance2) && \ + defined(VK_KHR_maintenance3) && \ + defined(VK_KHR_multiview) && \ + defined(VK_KHR_push_descriptor) && \ + defined(VK_KHR_relaxed_block_layout) && \ + defined(VK_KHR_sampler_mirror_clamp_to_edge) && \ + defined(VK_KHR_separate_depth_stencil_layouts) && \ + defined(VK_KHR_shader_draw_parameters) && \ + defined(VK_KHR_shader_float16_int8) && \ + defined(VK_KHR_shader_float_controls) && \ + defined(VK_KHR_shader_non_semantic_info) && \ + defined(VK_KHR_shader_subgroup_extended_types) && \ + defined(VK_KHR_spirv_1_4) && \ + defined(VK_KHR_storage_buffer_storage_class) && \ + defined(VK_KHR_swapchain) && \ + defined(VK_KHR_swapchain_mutable_format) && \ + defined(VK_KHR_synchronization2) && \ + defined(VK_KHR_timeline_semaphore) && \ + defined(VK_KHR_uniform_buffer_standard_layout) && \ + defined(VK_KHR_variable_pointers) +# define VP_LUNARG_desktop_baseline_2024 1 +# define VP_LUNARG_DESKTOP_BASELINE_2024_NAME "VP_LUNARG_desktop_baseline_2024" +# define VP_LUNARG_DESKTOP_BASELINE_2024_SPEC_VERSION 1 +# define VP_LUNARG_DESKTOP_BASELINE_2024_MIN_API_VERSION VK_MAKE_VERSION(1, 2, 197) #endif #if defined(VK_VERSION_1_0) -#define VP_LUNARG_minimum_requirements_1_0 1 -#define VP_LUNARG_MINIMUM_REQUIREMENTS_1_0_NAME "VP_LUNARG_minimum_requirements_1_0" -#define VP_LUNARG_MINIMUM_REQUIREMENTS_1_0_SPEC_VERSION 1 -#define VP_LUNARG_MINIMUM_REQUIREMENTS_1_0_MIN_API_VERSION VK_MAKE_VERSION(1, 0, 68) +# define VP_LUNARG_minimum_requirements_1_0 1 +# define VP_LUNARG_MINIMUM_REQUIREMENTS_1_0_NAME "VP_LUNARG_minimum_requirements_1_0" +# define VP_LUNARG_MINIMUM_REQUIREMENTS_1_0_SPEC_VERSION 1 +# define VP_LUNARG_MINIMUM_REQUIREMENTS_1_0_MIN_API_VERSION VK_MAKE_VERSION(1, 0, 68) #endif #if defined(VK_VERSION_1_1) -#define VP_LUNARG_minimum_requirements_1_1 1 -#define VP_LUNARG_MINIMUM_REQUIREMENTS_1_1_NAME "VP_LUNARG_minimum_requirements_1_1" -#define VP_LUNARG_MINIMUM_REQUIREMENTS_1_1_SPEC_VERSION 1 -#define VP_LUNARG_MINIMUM_REQUIREMENTS_1_1_MIN_API_VERSION VK_MAKE_VERSION(1, 1, 108) +# define VP_LUNARG_minimum_requirements_1_1 1 +# define VP_LUNARG_MINIMUM_REQUIREMENTS_1_1_NAME "VP_LUNARG_minimum_requirements_1_1" +# define VP_LUNARG_MINIMUM_REQUIREMENTS_1_1_SPEC_VERSION 1 +# define VP_LUNARG_MINIMUM_REQUIREMENTS_1_1_MIN_API_VERSION VK_MAKE_VERSION(1, 1, 108) #endif #if defined(VK_VERSION_1_2) -#define VP_LUNARG_minimum_requirements_1_2 1 -#define VP_LUNARG_MINIMUM_REQUIREMENTS_1_2_NAME "VP_LUNARG_minimum_requirements_1_2" -#define VP_LUNARG_MINIMUM_REQUIREMENTS_1_2_SPEC_VERSION 1 -#define VP_LUNARG_MINIMUM_REQUIREMENTS_1_2_MIN_API_VERSION VK_MAKE_VERSION(1, 2, 131) +# define VP_LUNARG_minimum_requirements_1_2 1 +# define VP_LUNARG_MINIMUM_REQUIREMENTS_1_2_NAME "VP_LUNARG_minimum_requirements_1_2" +# define VP_LUNARG_MINIMUM_REQUIREMENTS_1_2_SPEC_VERSION 1 +# define VP_LUNARG_MINIMUM_REQUIREMENTS_1_2_MIN_API_VERSION VK_MAKE_VERSION(1, 2, 131) #endif #if defined(VK_VERSION_1_3) -#define VP_LUNARG_minimum_requirements_1_3 1 -#define VP_LUNARG_MINIMUM_REQUIREMENTS_1_3_NAME "VP_LUNARG_minimum_requirements_1_3" -#define VP_LUNARG_MINIMUM_REQUIREMENTS_1_3_SPEC_VERSION 1 -#define VP_LUNARG_MINIMUM_REQUIREMENTS_1_3_MIN_API_VERSION VK_MAKE_VERSION(1, 3, 204) +# define VP_LUNARG_minimum_requirements_1_3 1 +# define VP_LUNARG_MINIMUM_REQUIREMENTS_1_3_NAME "VP_LUNARG_minimum_requirements_1_3" +# define VP_LUNARG_MINIMUM_REQUIREMENTS_1_3_SPEC_VERSION 1 +# define VP_LUNARG_MINIMUM_REQUIREMENTS_1_3_MIN_API_VERSION VK_MAKE_VERSION(1, 3, 204) #endif #define VP_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 2, 0, VK_HEADER_VERSION) #define VP_MAX_PROFILE_NAME_SIZE 256U -typedef struct VpProfileProperties { - char profileName[VP_MAX_PROFILE_NAME_SIZE]; - uint32_t specVersion; +typedef struct VpProfileProperties +{ + char profileName[VP_MAX_PROFILE_NAME_SIZE]; + uint32_t specVersion; } VpProfileProperties; -typedef struct VpBlockProperties { - VpProfileProperties profiles; - uint32_t apiVersion; - char blockName[VP_MAX_PROFILE_NAME_SIZE]; +typedef struct VpBlockProperties +{ + VpProfileProperties profiles; + uint32_t apiVersion; + char blockName[VP_MAX_PROFILE_NAME_SIZE]; } VpBlockProperties; -typedef enum VpInstanceCreateFlagBits { - VP_INSTANCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +typedef struct VpVideoProfileProperties +{ + char name[VP_MAX_PROFILE_NAME_SIZE]; +} VpVideoProfileProperties; + +typedef enum VpInstanceCreateFlagBits +{ + VP_INSTANCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VpInstanceCreateFlagBits; typedef VkFlags VpInstanceCreateFlags; -typedef struct VpInstanceCreateInfo { - const VkInstanceCreateInfo* pCreateInfo; - VpInstanceCreateFlags flags; - uint32_t enabledFullProfileCount; - const VpProfileProperties* pEnabledFullProfiles; - uint32_t enabledProfileBlockCount; - const VpBlockProperties* pEnabledProfileBlocks; +typedef struct VpInstanceCreateInfo +{ + const VkInstanceCreateInfo *pCreateInfo; + VpInstanceCreateFlags flags; + uint32_t enabledFullProfileCount; + const VpProfileProperties *pEnabledFullProfiles; + uint32_t enabledProfileBlockCount; + const VpBlockProperties *pEnabledProfileBlocks; } VpInstanceCreateInfo; -typedef enum VpDeviceCreateFlagBits { - VP_DEVICE_CREATE_DISABLE_ROBUST_BUFFER_ACCESS_BIT = 0x0000001, - VP_DEVICE_CREATE_DISABLE_ROBUST_IMAGE_ACCESS_BIT = 0x0000002, - VP_DEVICE_CREATE_DISABLE_ROBUST_ACCESS = - VP_DEVICE_CREATE_DISABLE_ROBUST_BUFFER_ACCESS_BIT | VP_DEVICE_CREATE_DISABLE_ROBUST_IMAGE_ACCESS_BIT, +typedef enum VpDeviceCreateFlagBits +{ + VP_DEVICE_CREATE_DISABLE_ROBUST_BUFFER_ACCESS_BIT = 0x0000001, + VP_DEVICE_CREATE_DISABLE_ROBUST_IMAGE_ACCESS_BIT = 0x0000002, + VP_DEVICE_CREATE_DISABLE_ROBUST_ACCESS = + VP_DEVICE_CREATE_DISABLE_ROBUST_BUFFER_ACCESS_BIT | VP_DEVICE_CREATE_DISABLE_ROBUST_IMAGE_ACCESS_BIT, - VP_DEVICE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF + VP_DEVICE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VpDeviceCreateFlagBits; typedef VkFlags VpDeviceCreateFlags; -typedef struct VpDeviceCreateInfo { - const VkDeviceCreateInfo* pCreateInfo; - VpDeviceCreateFlags flags; - uint32_t enabledFullProfileCount; - const VpProfileProperties* pEnabledFullProfiles; - uint32_t enabledProfileBlockCount; - const VpBlockProperties* pEnabledProfileBlocks; +typedef struct VpDeviceCreateInfo +{ + const VkDeviceCreateInfo *pCreateInfo; + VpDeviceCreateFlags flags; + uint32_t enabledFullProfileCount; + const VpProfileProperties *pEnabledFullProfiles; + uint32_t enabledProfileBlockCount; + const VpBlockProperties *pEnabledProfileBlocks; } VpDeviceCreateInfo; VK_DEFINE_HANDLE(VpCapabilities) -typedef enum VpCapabilitiesCreateFlagBits { - VP_PROFILE_CREATE_STATIC_BIT = (1 << 0), - //VP_PROFILE_CREATE_DYNAMIC_BIT = (1 << 1), - VP_PROFILE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +typedef enum VpCapabilitiesCreateFlagBits +{ + VP_PROFILE_CREATE_STATIC_BIT = (1 << 0), + // VP_PROFILE_CREATE_DYNAMIC_BIT = (1 << 1), + VP_PROFILE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VpCapabilitiesCreateFlagBits; typedef VkFlags VpCapabilitiesCreateFlags; @@ -277,411 +449,785 @@ typedef VkFlags VpCapabilitiesCreateFlags; // Pointers to some Vulkan functions - a subset used by the library. // Used in VpCapabilitiesCreateInfo::pVulkanFunctions. -typedef struct VpVulkanFunctions { - /// Required when using VP_DYNAMIC_VULKAN_FUNCTIONS. - PFN_vkGetInstanceProcAddr GetInstanceProcAddr; - /// Required when using VP_DYNAMIC_VULKAN_FUNCTIONS. - PFN_vkGetDeviceProcAddr GetDeviceProcAddr; - PFN_vkEnumerateInstanceVersion EnumerateInstanceVersion; - PFN_vkEnumerateInstanceExtensionProperties EnumerateInstanceExtensionProperties; - PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties; - PFN_vkGetPhysicalDeviceFeatures2 GetPhysicalDeviceFeatures2; - PFN_vkGetPhysicalDeviceProperties2 GetPhysicalDeviceProperties2; - PFN_vkGetPhysicalDeviceFormatProperties2 GetPhysicalDeviceFormatProperties2; - PFN_vkGetPhysicalDeviceQueueFamilyProperties2 GetPhysicalDeviceQueueFamilyProperties2; - PFN_vkCreateInstance CreateInstance; - PFN_vkCreateDevice CreateDevice; +typedef struct VpVulkanFunctions +{ + /// Required when using VP_DYNAMIC_VULKAN_FUNCTIONS. + PFN_vkGetInstanceProcAddr GetInstanceProcAddr; + /// Required when using VP_DYNAMIC_VULKAN_FUNCTIONS. + PFN_vkGetDeviceProcAddr GetDeviceProcAddr; + PFN_vkEnumerateInstanceVersion EnumerateInstanceVersion; + PFN_vkEnumerateInstanceExtensionProperties EnumerateInstanceExtensionProperties; + PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties; + PFN_vkGetPhysicalDeviceFeatures2 GetPhysicalDeviceFeatures2; + PFN_vkGetPhysicalDeviceProperties2 GetPhysicalDeviceProperties2; + PFN_vkGetPhysicalDeviceFormatProperties2 GetPhysicalDeviceFormatProperties2; + PFN_vkGetPhysicalDeviceQueueFamilyProperties2 GetPhysicalDeviceQueueFamilyProperties2; + PFN_vkCreateInstance CreateInstance; + PFN_vkCreateDevice CreateDevice; } VpVulkanFunctions; /// Description of a Allocator to be created. typedef struct VpCapabilitiesCreateInfo { - /// Flags for created allocator. Use #VpInstanceCreateFlagBits enum. - VpCapabilitiesCreateFlags flags; - uint32_t apiVersion; - const VpVulkanFunctions* pVulkanFunctions; + /// Flags for created allocator. Use #VpInstanceCreateFlagBits enum. + VpCapabilitiesCreateFlags flags; + uint32_t apiVersion; + const VpVulkanFunctions *pVulkanFunctions; } VpCapabilitiesCreateInfo; VPAPI_ATTR VkResult vpCreateCapabilities( - const VpCapabilitiesCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VpCapabilities* pCapabilities); + const VpCapabilitiesCreateInfo *pCreateInfo, + const VkAllocationCallbacks *pAllocator, + VpCapabilities *pCapabilities); /// Destroys allocator object. VPAPI_ATTR void vpDestroyCapabilities( - VpCapabilities capabilities, - const VkAllocationCallbacks* pAllocator); + VpCapabilities capabilities, + const VkAllocationCallbacks *pAllocator); // Query the list of available profiles in the library VPAPI_ATTR VkResult vpGetProfiles( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - uint32_t* pPropertyCount, - VpProfileProperties* pProperties); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + uint32_t *pPropertyCount, + VpProfileProperties *pProperties); // List the required profiles of a profile VPAPI_ATTR VkResult vpGetProfileRequiredProfiles( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - uint32_t* pPropertyCount, - VpProfileProperties* pProperties); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + uint32_t *pPropertyCount, + VpProfileProperties *pProperties); // Query the profile required Vulkan API version VPAPI_ATTR uint32_t vpGetProfileAPIVersion( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile); // List the recommended fallback profiles of a profile VPAPI_ATTR VkResult vpGetProfileFallbacks( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - uint32_t* pPropertyCount, - VpProfileProperties* pProperties); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + uint32_t *pPropertyCount, + VpProfileProperties *pProperties); // Query whether the profile has multiple variants. Profiles with multiple variants can only use vpGetInstanceProfileSupport and vpGetPhysicalDeviceProfileSupport capabilities of the library. Other function will return a VK_ERROR_UNKNOWN error VPAPI_ATTR VkResult vpHasMultipleVariantsProfile( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - VkBool32* pHasMultipleVariants); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + VkBool32 *pHasMultipleVariants); // Check whether a profile is supported at the instance level VPAPI_ATTR VkResult vpGetInstanceProfileSupport( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const char* pLayerName, - const VpProfileProperties* pProfile, - VkBool32* pSupported); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const char *pLayerName, + const VpProfileProperties *pProfile, + VkBool32 *pSupported); // Check whether a variant of a profile is supported at the instance level and report this list of blocks used to validate the profiles VPAPI_ATTR VkResult vpGetInstanceProfileVariantsSupport( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const char* pLayerName, - const VpProfileProperties* pProfile, - VkBool32* pSupported, - uint32_t* pPropertyCount, - VpBlockProperties* pProperties); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const char *pLayerName, + const VpProfileProperties *pProfile, + VkBool32 *pSupported, + uint32_t *pPropertyCount, + VpBlockProperties *pProperties); // Create a VkInstance with the profile instance extensions enabled VPAPI_ATTR VkResult vpCreateInstance( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpInstanceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkInstance* pInstance); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpInstanceCreateInfo *pCreateInfo, + const VkAllocationCallbacks *pAllocator, + VkInstance *pInstance); // Check whether a profile is supported by the physical device VPAPI_ATTR VkResult vpGetPhysicalDeviceProfileSupport( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - VkInstance instance, - VkPhysicalDevice physicalDevice, - const VpProfileProperties* pProfile, - VkBool32* pSupported); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + VkInstance instance, + VkPhysicalDevice physicalDevice, + const VpProfileProperties *pProfile, + VkBool32 *pSupported); // Check whether a variant of a profile is supported by the physical device and report this list of blocks used to validate the profiles VPAPI_ATTR VkResult vpGetPhysicalDeviceProfileVariantsSupport( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - VkInstance instance, - VkPhysicalDevice physicalDevice, - const VpProfileProperties* pProfile, - VkBool32* pSupported, - uint32_t* pPropertyCount, - VpBlockProperties* pProperties); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + VkInstance instance, + VkPhysicalDevice physicalDevice, + const VpProfileProperties *pProfile, + VkBool32 *pSupported, + uint32_t *pPropertyCount, + VpBlockProperties *pProperties); // Create a VkDevice with the profile features and device extensions enabled VPAPI_ATTR VkResult vpCreateDevice( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - VkPhysicalDevice physicalDevice, - const VpDeviceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDevice* pDevice); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + VkPhysicalDevice physicalDevice, + const VpDeviceCreateInfo *pCreateInfo, + const VkAllocationCallbacks *pAllocator, + VkDevice *pDevice); // Query the list of instance extensions of a profile VPAPI_ATTR VkResult vpGetProfileInstanceExtensionProperties( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t *pPropertyCount, + VkExtensionProperties *pProperties); // Query the list of device extensions of a profile VPAPI_ATTR VkResult vpGetProfileDeviceExtensionProperties( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t *pPropertyCount, + VkExtensionProperties *pProperties); // Fill the feature structures with the requirements of a profile VPAPI_ATTR VkResult vpGetProfileFeatures( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - void* pNext); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + void *pNext); // Query the list of feature structure types specified by the profile VPAPI_ATTR VkResult vpGetProfileFeatureStructureTypes( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - uint32_t* pStructureTypeCount, - VkStructureType* pStructureTypes); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t *pStructureTypeCount, + VkStructureType *pStructureTypes); // Fill the property structures with the requirements of a profile VPAPI_ATTR VkResult vpGetProfileProperties( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - void* pNext); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + void *pNext); // Query the list of property structure types specified by the profile VPAPI_ATTR VkResult vpGetProfilePropertyStructureTypes( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - uint32_t* pStructureTypeCount, - VkStructureType* pStructureTypes); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t *pStructureTypeCount, + VkStructureType *pStructureTypes); + +// Fill the queue family property structures with the requirements of a profile +VPAPI_ATTR VkResult vpGetProfileQueueFamilyProperties( +#ifdef VP_USE_OBJECT + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t *pPropertyCount, + VkQueueFamilyProperties2KHR *pProperties); + +// Query the list of queue family property structure types specified by the profile +VPAPI_ATTR VkResult vpGetProfileQueueFamilyStructureTypes( +#ifdef VP_USE_OBJECT + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t *pStructureTypeCount, + VkStructureType *pStructureTypes); // Query the list of formats with specified requirements by a profile VPAPI_ATTR VkResult vpGetProfileFormats( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - uint32_t* pFormatCount, - VkFormat* pFormats); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t *pFormatCount, + VkFormat *pFormats); // Query the requirements of a format for a profile VPAPI_ATTR VkResult vpGetProfileFormatProperties( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - VkFormat format, - void* pNext); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + VkFormat format, + void *pNext); // Query the list of format structure types specified by the profile VPAPI_ATTR VkResult vpGetProfileFormatStructureTypes( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - uint32_t* pStructureTypeCount, - VkStructureType* pStructureTypes); + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t *pStructureTypeCount, + VkStructureType *pStructureTypes); + +#ifdef VK_KHR_video_queue +// Query the list of video profiles specified by the profile +VPAPI_ATTR VkResult vpGetProfileVideoProfiles( +# ifdef VP_USE_OBJECT + VpCapabilities capabilities, +# endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t *pVideoProfileCount, + VpVideoProfileProperties *pVideoProfiles); + +// Query the video profile info structures for a video profile defined by a profile +VPAPI_ATTR VkResult vpGetProfileVideoProfileInfo( +# ifdef VP_USE_OBJECT + VpCapabilities capabilities, +# endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t videoProfileIndex, + VkVideoProfileInfoKHR *pVideoProfileInfo); + +// Query the list of video profile info structure types specified by the profile for a video profile +VPAPI_ATTR VkResult vpGetProfileVideoProfileInfoStructureTypes( +# ifdef VP_USE_OBJECT + VpCapabilities capabilities, +# endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t videoProfileIndex, + uint32_t *pStructureTypeCount, + VkStructureType *pStructureTypes); + +// Query the video capabilities requirements for a video profile defined by a profile +VPAPI_ATTR VkResult vpGetProfileVideoCapabilities( +# ifdef VP_USE_OBJECT + VpCapabilities capabilities, +# endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t videoProfileIndex, + void *pNext); + +// Query the list of video capability structure types specified by the profile for a video profile +VPAPI_ATTR VkResult vpGetProfileVideoCapabilityStructureTypes( +# ifdef VP_USE_OBJECT + VpCapabilities capabilities, +# endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t videoProfileIndex, + uint32_t *pStructureTypeCount, + VkStructureType *pStructureTypes); + +// Query the video format property requirements for a video profile defined by a profile +VPAPI_ATTR VkResult vpGetProfileVideoFormatProperties( +# ifdef VP_USE_OBJECT + VpCapabilities capabilities, +# endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t videoProfileIndex, + uint32_t *pPropertyCount, + VkVideoFormatPropertiesKHR *pProperties); + +// Query the list of video format property structure types specified by the profile for a video profile +VPAPI_ATTR VkResult vpGetProfileVideoFormatStructureTypes( +# ifdef VP_USE_OBJECT + VpCapabilities capabilities, +# endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t videoProfileIndex, + uint32_t *pStructureTypeCount, + VkStructureType *pStructureTypes); +#endif // VK_KHR_video_queue -namespace detail { +#include +#ifndef VP_DEBUG_MESSAGE_CALLBACK +# if defined(ANDROID) || defined(__ANDROID__) +# include +# define VP_DEBUG_MESSAGE_CALLBACK(MSG) \ + __android_log_print(ANDROID_LOG_ERROR, "Profiles ERROR", "%s", MSG) +# else +# define VP_DEBUG_MESSAGE_CALLBACK(MSG) fprintf(stderr, "%s\n", MSG) +# endif +#else +void VP_DEBUG_MESSAGE_CALLBACK(const char *); +#endif -VPAPI_ATTR std::string FormatString(const char* message, ...) { - std::size_t const STRING_BUFFER(4096); +#define VP_DEBUG_MSG(MSG) VP_DEBUG_MESSAGE_CALLBACK((MSG)) +#define VP_DEBUG_MSGF(MSGFMT, ...) \ + { \ + char msg[1024]; \ + snprintf(msg, sizeof(msg) - 1, (MSGFMT), __VA_ARGS__); \ + VP_DEBUG_MESSAGE_CALLBACK(msg); \ + } +#define VP_DEBUG_COND_MSG(COND, MSG) \ + if ((COND)) \ + { \ + VP_DEBUG_MSG((MSG)); \ + } +#define VP_DEBUG_COND_MSGF(COND, MSGFMT, ...) \ + if ((COND)) \ + { \ + VP_DEBUG_MSGF((MSGFMT), __VA_ARGS__); \ + } + +namespace detail +{ - assert(message != nullptr); - assert(strlen(message) >= 1 && strlen(message) < STRING_BUFFER); +VPAPI_ATTR std::string FormatString(const char *message, ...) +{ + std::size_t const STRING_BUFFER(4096); - char buffer[STRING_BUFFER]; - va_list list; + assert(message != nullptr); + assert(strlen(message) >= 1 && strlen(message) < STRING_BUFFER); - va_start(list, message); - vsnprintf(buffer, STRING_BUFFER, message, list); - va_end(list); + char buffer[STRING_BUFFER]; + va_list list; - return buffer; -} + va_start(list, message); + vsnprintf(buffer, STRING_BUFFER, message, list); + va_end(list); -VPAPI_ATTR const void* vpGetStructure(const void* pNext, VkStructureType type) { - const VkBaseOutStructure* p = static_cast(pNext); - while (p != nullptr) { - if (p->sType == type) return p; - p = p->pNext; - } - return nullptr; + return buffer; } -VPAPI_ATTR void* vpGetStructure(void* pNext, VkStructureType type) { - VkBaseOutStructure* p = static_cast(pNext); - while (p != nullptr) { - if (p->sType == type) return p; - p = p->pNext; - } - return nullptr; +VPAPI_ATTR const void *vpGetStructure(const void *pNext, VkStructureType type) +{ + const VkBaseOutStructure *p = static_cast(pNext); + while (p != nullptr) + { + if (p->sType == type) + return p; + p = p->pNext; + } + return nullptr; } -VPAPI_ATTR VkBaseOutStructure* vpExtractStructure(VkPhysicalDeviceFeatures2KHR* pFeatures, VkStructureType structureType) { - if (structureType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR) { - return nullptr; - } - - VkBaseOutStructure* current = reinterpret_cast(pFeatures); - VkBaseOutStructure* previous = nullptr; - VkBaseOutStructure* found = nullptr; - - while (current != nullptr) { - if (structureType == current->sType) { - found = current; - if (previous != nullptr) { - previous->pNext = current->pNext; - } - current = nullptr; - } else { - previous = current; - current = current->pNext; - } - } - - if (found != nullptr) { - found->pNext = nullptr; - return found; - } else { - return nullptr; - } +VPAPI_ATTR void *vpGetStructure(void *pNext, VkStructureType type) +{ + VkBaseOutStructure *p = static_cast(pNext); + while (p != nullptr) + { + if (p->sType == type) + return p; + p = p->pNext; + } + return nullptr; } -VPAPI_ATTR void GatherStructureTypes(std::vector& structureTypes, VkBaseOutStructure* pNext) { - while (pNext) { - if (std::find(structureTypes.begin(), structureTypes.end(), pNext->sType) == structureTypes.end()) { - structureTypes.push_back(pNext->sType); - } +VPAPI_ATTR VkBaseOutStructure *vpExtractStructure(VkPhysicalDeviceFeatures2KHR *pFeatures, VkStructureType structureType) +{ + if (structureType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR) + { + return nullptr; + } + + VkBaseOutStructure *current = reinterpret_cast(pFeatures); + VkBaseOutStructure *previous = nullptr; + VkBaseOutStructure *found = nullptr; + + while (current != nullptr) + { + if (structureType == current->sType) + { + found = current; + if (previous != nullptr) + { + previous->pNext = current->pNext; + } + current = nullptr; + } + else + { + previous = current; + current = current->pNext; + } + } + + if (found != nullptr) + { + found->pNext = nullptr; + return found; + } + else + { + return nullptr; + } +} - pNext = pNext->pNext; - } +VPAPI_ATTR void GatherStructureTypes(std::vector &structureTypes, VkBaseOutStructure *pNext) +{ + while (pNext) + { + if (std::find(structureTypes.begin(), structureTypes.end(), pNext->sType) == structureTypes.end()) + { + structureTypes.push_back(pNext->sType); + } + + pNext = pNext->pNext; + } } -VPAPI_ATTR bool isMultiple(double source, double multiple) { - double mod = std::fmod(source, multiple); - return std::abs(mod) < 0.0001; +VPAPI_ATTR bool isMultiple(double source, double multiple) +{ + double mod = std::fmod(source, multiple); + return std::abs(mod) < 0.0001; } -VPAPI_ATTR bool isPowerOfTwo(double source) { - double mod = std::fmod(source, 1.0); - if (std::abs(mod) >= 0.0001) return false; +VPAPI_ATTR bool isPowerOfTwo(double source) +{ + double mod = std::fmod(source, 1.0); + if (std::abs(mod) >= 0.0001) + return false; - std::uint64_t value = static_cast(std::abs(source)); - return !(value & (value - static_cast(1))); + std::uint64_t value = static_cast(std::abs(source)); + return !(value & (value - static_cast(1))); } -using PFN_vpStructFiller = void(*)(VkBaseOutStructure* p); -using PFN_vpStructComparator = bool(*)(VkBaseOutStructure* p); -using PFN_vpStructChainerCb = void(*)(VkBaseOutStructure* p, void* pUser); -using PFN_vpStructChainer = void(*)(VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb); +using PFN_vpStructFiller = void (*)(VkBaseOutStructure *p); +using PFN_vpStructComparator = bool (*)(VkBaseOutStructure *p); +using PFN_vpStructChainerCb = void (*)(VkBaseOutStructure *p, void *pUser); +using PFN_vpStructChainer = void (*)(VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb); +using PFN_vpStructArrayChainerCb = void (*)(uint32_t count, VkBaseOutStructure *p, void *pUser); +using PFN_vpStructArrayChainer = void (*)(uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb); + +struct VpFeatureDesc +{ + PFN_vpStructFiller pfnFiller; + PFN_vpStructComparator pfnComparator; +}; + +struct VpPropertyDesc +{ + PFN_vpStructFiller pfnFiller; + PFN_vpStructComparator pfnComparator; +}; + +struct VpQueueFamilyDesc +{ + PFN_vpStructFiller pfnFiller; + PFN_vpStructComparator pfnComparator; +}; + +struct VpFormatDesc +{ + VkFormat format; + PFN_vpStructFiller pfnFiller; + PFN_vpStructComparator pfnComparator; +}; + +struct VpStructChainerDesc +{ + PFN_vpStructChainer pfnFeature; + PFN_vpStructChainer pfnProperty; + PFN_vpStructArrayChainer pfnQueueFamily; + PFN_vpStructChainer pfnFormat; +}; -struct VpFeatureDesc { - PFN_vpStructFiller pfnFiller; - PFN_vpStructComparator pfnComparator; +struct VpVideoProfileInfoDesc +{ + PFN_vpStructFiller pfnFiller; + PFN_vpStructComparator pfnComparator; }; -struct VpPropertyDesc { - PFN_vpStructFiller pfnFiller; - PFN_vpStructComparator pfnComparator; +struct VpVideoCapabilityDesc +{ + PFN_vpStructFiller pfnFiller; + PFN_vpStructComparator pfnComparator; }; -struct VpQueueFamilyDesc { - PFN_vpStructFiller pfnFiller; - PFN_vpStructComparator pfnComparator; +struct VpVideoFormatDesc +{ + PFN_vpStructFiller pfnFiller; + PFN_vpStructComparator pfnComparator; }; -struct VpFormatDesc { - VkFormat format; - PFN_vpStructFiller pfnFiller; - PFN_vpStructComparator pfnComparator; +struct VpVideoProfileStructChainerDesc +{ + PFN_vpStructChainer pfnInfo; + PFN_vpStructChainer pfnCapability; + PFN_vpStructArrayChainer pfnFormat; }; -struct VpStructChainerDesc { - PFN_vpStructChainer pfnFeature; - PFN_vpStructChainer pfnProperty; - PFN_vpStructChainer pfnQueueFamily; - PFN_vpStructChainer pfnFormat; +struct VpVideoProfileDesc +{ + VpVideoProfileProperties properties; + + uint32_t infoStructTypeCount; + const VkStructureType *pInfoStructTypes; + VpVideoProfileInfoDesc info; + + uint32_t capabilityStructTypeCount; + const VkStructureType *pCapabilityStructTypes; + VpVideoCapabilityDesc capability; + + uint32_t formatStructTypeCount; + const VkStructureType *pFormatStructTypes; + uint32_t formatCount; + const VpVideoFormatDesc *pFormats; + + VpVideoProfileStructChainerDesc chainers; }; -struct VpVariantDesc { - char blockName[VP_MAX_PROFILE_NAME_SIZE]; +struct VpVariantDesc +{ + char blockName[VP_MAX_PROFILE_NAME_SIZE]; + + uint32_t instanceExtensionCount; + const VkExtensionProperties *pInstanceExtensions; - uint32_t instanceExtensionCount; - const VkExtensionProperties* pInstanceExtensions; + uint32_t deviceExtensionCount; + const VkExtensionProperties *pDeviceExtensions; - uint32_t deviceExtensionCount; - const VkExtensionProperties* pDeviceExtensions; + uint32_t featureStructTypeCount; + const VkStructureType *pFeatureStructTypes; + VpFeatureDesc feature; - uint32_t featureStructTypeCount; - const VkStructureType* pFeatureStructTypes; - VpFeatureDesc feature; + uint32_t propertyStructTypeCount; + const VkStructureType *pPropertyStructTypes; + VpPropertyDesc property; - uint32_t propertyStructTypeCount; - const VkStructureType* pPropertyStructTypes; - VpPropertyDesc property; + uint32_t queueFamilyStructTypeCount; + const VkStructureType *pQueueFamilyStructTypes; + uint32_t queueFamilyCount; + const VpQueueFamilyDesc *pQueueFamilies; - uint32_t queueFamilyStructTypeCount; - const VkStructureType* pQueueFamilyStructTypes; - uint32_t queueFamilyCount; - const VpQueueFamilyDesc* pQueueFamilies; + uint32_t formatStructTypeCount; + const VkStructureType *pFormatStructTypes; + uint32_t formatCount; + const VpFormatDesc *pFormats; - uint32_t formatStructTypeCount; - const VkStructureType* pFormatStructTypes; - uint32_t formatCount; - const VpFormatDesc* pFormats; + VpStructChainerDesc chainers; - VpStructChainerDesc chainers; + uint32_t videoProfileCount; + const VpVideoProfileDesc *pVideoProfiles; }; -struct VpCapabilitiesDesc { - uint32_t variantCount; - const VpVariantDesc* pVariants; +struct VpCapabilitiesDesc +{ + uint32_t variantCount; + const VpVariantDesc *pVariants; }; -struct VpProfileDesc { - VpProfileProperties props; - uint32_t minApiVersion; +struct VpProfileDesc +{ + VpProfileProperties props; + uint32_t minApiVersion; - const detail::VpVariantDesc* pMergedCapabilities; + const detail::VpVariantDesc *pMergedCapabilities; - uint32_t requiredProfileCount; - const VpProfileProperties* pRequiredProfiles; + uint32_t requiredProfileCount; + const VpProfileProperties *pRequiredProfiles; - uint32_t requiredCapabilityCount; - const VpCapabilitiesDesc* pRequiredCapabilities; + uint32_t requiredCapabilityCount; + const VpCapabilitiesDesc *pRequiredCapabilities; - uint32_t fallbackCount; - const VpProfileProperties* pFallbacks; + uint32_t fallbackCount; + const VpProfileProperties *pFallbacks; }; template -VPAPI_ATTR bool vpCheckFlags(const T& actual, const uint64_t expected) { - return (actual & expected) == expected; +VPAPI_ATTR bool vpCheckFlags(const T &actual, const uint64_t expected) +{ + return (actual & expected) == expected; +} + +#ifdef VK_KHR_video_queue +VPAPI_ATTR void vpForEachMatchingVideoProfiles( + VkVideoProfileInfoKHR *pVideoProfileInfo, + void *pUser, + PFN_vpStructChainerCb pfnCb) +{ + const VkVideoChromaSubsamplingFlagsKHR chroma_subsampling_list[] = { + VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, + VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR, + VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR, + VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR}; + const VkVideoComponentBitDepthFlagsKHR bit_depth_list[] = { + VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, + VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR, + VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR}; + for (size_t chromaSubsampling_idx = 0; chromaSubsampling_idx < std::size(chroma_subsampling_list); ++chromaSubsampling_idx) + { + pVideoProfileInfo->chromaSubsampling = chroma_subsampling_list[chromaSubsampling_idx]; + for (size_t lumaBitDepth_idx = 0; lumaBitDepth_idx < std::size(bit_depth_list); ++lumaBitDepth_idx) + { + pVideoProfileInfo->lumaBitDepth = bit_depth_list[lumaBitDepth_idx]; + for (size_t chromaBitDepth_idx = 0; chromaBitDepth_idx < std::size(bit_depth_list); ++chromaBitDepth_idx) + { + pVideoProfileInfo->chromaBitDepth = bit_depth_list[chromaBitDepth_idx]; + { + pVideoProfileInfo->pNext = nullptr; + pVideoProfileInfo->videoCodecOperation = VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR; + VkVideoDecodeH264ProfileInfoKHR var_VideoDecodeH264ProfileInfoKHR = {VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR}; + var_VideoDecodeH264ProfileInfoKHR.pNext = pVideoProfileInfo->pNext; + pVideoProfileInfo->pNext = &var_VideoDecodeH264ProfileInfoKHR; + var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_BASELINE; + var_VideoDecodeH264ProfileInfoKHR.pictureLayout = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_MAIN; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_HIGH; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_BASELINE; + var_VideoDecodeH264ProfileInfoKHR.pictureLayout = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_MAIN; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_HIGH; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_BASELINE; + var_VideoDecodeH264ProfileInfoKHR.pictureLayout = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_MAIN; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_HIGH; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + } + { + pVideoProfileInfo->pNext = nullptr; + pVideoProfileInfo->videoCodecOperation = VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR; + VkVideoDecodeH265ProfileInfoKHR var_VideoDecodeH265ProfileInfoKHR = {VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR}; + var_VideoDecodeH265ProfileInfoKHR.pNext = pVideoProfileInfo->pNext; + pVideoProfileInfo->pNext = &var_VideoDecodeH265ProfileInfoKHR; + var_VideoDecodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN_10; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + } + { + pVideoProfileInfo->pNext = nullptr; + pVideoProfileInfo->videoCodecOperation = VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR; + VkVideoDecodeVP9ProfileInfoKHR var_VideoDecodeVP9ProfileInfoKHR = {VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR}; + var_VideoDecodeVP9ProfileInfoKHR.pNext = pVideoProfileInfo->pNext; + pVideoProfileInfo->pNext = &var_VideoDecodeVP9ProfileInfoKHR; + var_VideoDecodeVP9ProfileInfoKHR.stdProfile = STD_VIDEO_VP9_PROFILE_0; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeVP9ProfileInfoKHR.stdProfile = STD_VIDEO_VP9_PROFILE_1; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeVP9ProfileInfoKHR.stdProfile = STD_VIDEO_VP9_PROFILE_2; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeVP9ProfileInfoKHR.stdProfile = STD_VIDEO_VP9_PROFILE_3; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + } + { + pVideoProfileInfo->pNext = nullptr; + pVideoProfileInfo->videoCodecOperation = VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR; + VkVideoDecodeAV1ProfileInfoKHR var_VideoDecodeAV1ProfileInfoKHR = {VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR}; + var_VideoDecodeAV1ProfileInfoKHR.pNext = pVideoProfileInfo->pNext; + pVideoProfileInfo->pNext = &var_VideoDecodeAV1ProfileInfoKHR; + var_VideoDecodeAV1ProfileInfoKHR.stdProfile = STD_VIDEO_AV1_PROFILE_MAIN; + var_VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_TRUE; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeAV1ProfileInfoKHR.stdProfile = STD_VIDEO_AV1_PROFILE_HIGH; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeAV1ProfileInfoKHR.stdProfile = STD_VIDEO_AV1_PROFILE_PROFESSIONAL; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeAV1ProfileInfoKHR.stdProfile = STD_VIDEO_AV1_PROFILE_MAIN; + var_VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_FALSE; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeAV1ProfileInfoKHR.stdProfile = STD_VIDEO_AV1_PROFILE_HIGH; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoDecodeAV1ProfileInfoKHR.stdProfile = STD_VIDEO_AV1_PROFILE_PROFESSIONAL; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + } + { + pVideoProfileInfo->pNext = nullptr; + pVideoProfileInfo->videoCodecOperation = VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR; + VkVideoEncodeH264ProfileInfoKHR var_VideoEncodeH264ProfileInfoKHR = {VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR}; + var_VideoEncodeH264ProfileInfoKHR.pNext = pVideoProfileInfo->pNext; + pVideoProfileInfo->pNext = &var_VideoEncodeH264ProfileInfoKHR; + var_VideoEncodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_BASELINE; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoEncodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_MAIN; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoEncodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_HIGH; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoEncodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + } + { + pVideoProfileInfo->pNext = nullptr; + pVideoProfileInfo->videoCodecOperation = VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR; + VkVideoEncodeH265ProfileInfoKHR var_VideoEncodeH265ProfileInfoKHR = {VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR}; + var_VideoEncodeH265ProfileInfoKHR.pNext = pVideoProfileInfo->pNext; + pVideoProfileInfo->pNext = &var_VideoEncodeH265ProfileInfoKHR; + var_VideoEncodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoEncodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN_10; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoEncodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoEncodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoEncodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + } + { + pVideoProfileInfo->pNext = nullptr; + pVideoProfileInfo->videoCodecOperation = VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR; + VkVideoEncodeAV1ProfileInfoKHR var_VideoEncodeAV1ProfileInfoKHR = {VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR}; + var_VideoEncodeAV1ProfileInfoKHR.pNext = pVideoProfileInfo->pNext; + pVideoProfileInfo->pNext = &var_VideoEncodeAV1ProfileInfoKHR; + var_VideoEncodeAV1ProfileInfoKHR.stdProfile = STD_VIDEO_AV1_PROFILE_MAIN; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoEncodeAV1ProfileInfoKHR.stdProfile = STD_VIDEO_AV1_PROFILE_HIGH; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + var_VideoEncodeAV1ProfileInfoKHR.stdProfile = STD_VIDEO_AV1_PROFILE_PROFESSIONAL; + pfnCb(reinterpret_cast(pVideoProfileInfo), pUser); + } + } + } + } } +#endif // VK_KHR_video_queue #ifdef VP_ANDROID_15_minimums -namespace VP_ANDROID_15_MINIMUMS { +namespace VP_ANDROID_15_MINIMUMS +{ static const VkStructureType featureStructTypes[] = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, @@ -711,566 +1257,735 @@ static const VkStructureType formatStructTypes[] = { VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, }; -namespace MUST { +namespace blocks +{ +namespace MUST +{ + static const VkExtensionProperties instanceExtensions[] = { - VkExtensionProperties{ VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME, 1 }, + VkExtensionProperties{VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME, 1}, }; static const VkExtensionProperties deviceExtensions[] = { - VkExtensionProperties{ VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_EXT_4444_FORMATS_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_16BIT_STORAGE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_MAINTENANCE_5_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, 1 }, + VkExtensionProperties{VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_4444_FORMATS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_16BIT_STORAGE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_5_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, 1}, }; static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.drawIndirectFirstInstance = VK_TRUE; - s->features.samplerAnisotropy = VK_TRUE; - s->features.shaderImageGatherExtended = VK_TRUE; - s->features.shaderStorageImageExtendedFormats = VK_TRUE; - s->features.shaderStorageImageReadWithoutFormat = VK_TRUE; - s->features.shaderStorageImageWriteWithoutFormat = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - s->shaderFloat16 = VK_TRUE; - s->shaderInt8 = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: { - VkPhysicalDeviceCustomBorderColorFeaturesEXT* s = static_cast(static_cast(p)); - s->customBorderColors = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: { - VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* s = static_cast(static_cast(p)); - s->primitiveTopologyListRestart = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: { - VkPhysicalDeviceProvokingVertexFeaturesEXT* s = static_cast(static_cast(p)); - s->provokingVertexLast = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: { - VkPhysicalDeviceIndexTypeUint8FeaturesEXT* s = static_cast(static_cast(p)); - s->indexTypeUint8 = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: { - VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* s = static_cast(static_cast(p)); - s->vertexAttributeInstanceRateDivisor = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: { - VkPhysicalDeviceSamplerYcbcrConversionFeatures* s = static_cast(static_cast(p)); - s->samplerYcbcrConversion = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: { - VkPhysicalDeviceShaderFloat16Int8Features* s = static_cast(static_cast(p)); - s->shaderFloat16 = VK_TRUE; - s->shaderInt8 = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: { - VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* s = static_cast(static_cast(p)); - s->shaderSubgroupExtendedTypes = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: { - VkPhysicalDevice8BitStorageFeatures* s = static_cast(static_cast(p)); - s->storageBuffer8BitAccess = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: { - VkPhysicalDevice16BitStorageFeatures* s = static_cast(static_cast(p)); - s->storageBuffer16BitAccess = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.drawIndirectFirstInstance == VK_TRUE); - ret = ret && (s->features.samplerAnisotropy == VK_TRUE); - ret = ret && (s->features.shaderImageGatherExtended == VK_TRUE); - ret = ret && (s->features.shaderStorageImageExtendedFormats == VK_TRUE); - ret = ret && (s->features.shaderStorageImageReadWithoutFormat == VK_TRUE); - ret = ret && (s->features.shaderStorageImageWriteWithoutFormat == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - ret = ret && (s->shaderFloat16 == VK_TRUE); - ret = ret && (s->shaderInt8 == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: { - VkPhysicalDeviceCustomBorderColorFeaturesEXT* s = static_cast(static_cast(p)); - ret = ret && (s->customBorderColors == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: { - VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* s = static_cast(static_cast(p)); - ret = ret && (s->primitiveTopologyListRestart == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: { - VkPhysicalDeviceProvokingVertexFeaturesEXT* s = static_cast(static_cast(p)); - ret = ret && (s->provokingVertexLast == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: { - VkPhysicalDeviceIndexTypeUint8FeaturesEXT* s = static_cast(static_cast(p)); - ret = ret && (s->indexTypeUint8 == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: { - VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* s = static_cast(static_cast(p)); - ret = ret && (s->vertexAttributeInstanceRateDivisor == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: { - VkPhysicalDeviceSamplerYcbcrConversionFeatures* s = static_cast(static_cast(p)); - ret = ret && (s->samplerYcbcrConversion == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: { - VkPhysicalDeviceShaderFloat16Int8Features* s = static_cast(static_cast(p)); - ret = ret && (s->shaderFloat16 == VK_TRUE); - ret = ret && (s->shaderInt8 == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: { - VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* s = static_cast(static_cast(p)); - ret = ret && (s->shaderSubgroupExtendedTypes == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: { - VkPhysicalDevice8BitStorageFeatures* s = static_cast(static_cast(p)); - ret = ret && (s->storageBuffer8BitAccess == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: { - VkPhysicalDevice16BitStorageFeatures* s = static_cast(static_cast(p)); - ret = ret && (s->storageBuffer16BitAccess == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.drawIndirectFirstInstance = VK_TRUE; + s->features.samplerAnisotropy = VK_TRUE; + s->features.shaderImageGatherExtended = VK_TRUE; + s->features.shaderStorageImageExtendedFormats = VK_TRUE; + s->features.shaderStorageImageReadWithoutFormat = VK_TRUE; + s->features.shaderStorageImageWriteWithoutFormat = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *s = static_cast(static_cast(p)); + s->shaderFloat16 = VK_TRUE; + s->shaderInt8 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: + { + VkPhysicalDeviceCustomBorderColorFeaturesEXT *s = static_cast(static_cast(p)); + s->customBorderColors = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: + { + VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *s = static_cast(static_cast(p)); + s->primitiveTopologyListRestart = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: + { + VkPhysicalDeviceProvokingVertexFeaturesEXT *s = static_cast(static_cast(p)); + s->provokingVertexLast = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: + { + VkPhysicalDeviceIndexTypeUint8FeaturesEXT *s = static_cast(static_cast(p)); + s->indexTypeUint8 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: + { + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR *s = static_cast(static_cast(p)); + s->vertexAttributeInstanceRateDivisor = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + { + VkPhysicalDeviceSamplerYcbcrConversionFeatures *s = static_cast(static_cast(p)); + s->samplerYcbcrConversion = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + { + VkPhysicalDeviceShaderFloat16Int8Features *s = static_cast(static_cast(p)); + s->shaderFloat16 = VK_TRUE; + s->shaderInt8 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + { + VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *s = static_cast(static_cast(p)); + s->shaderSubgroupExtendedTypes = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + { + VkPhysicalDevice8BitStorageFeatures *s = static_cast(static_cast(p)); + s->storageBuffer8BitAccess = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + { + VkPhysicalDevice16BitStorageFeatures *s = static_cast(static_cast(p)); + s->storageBuffer16BitAccess = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.drawIndirectFirstInstance == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.samplerAnisotropy == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderImageGatherExtended == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderImageGatherExtended == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderImageGatherExtended == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageExtendedFormats == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageReadWithoutFormat == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageReadWithoutFormat == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageReadWithoutFormat == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageWriteWithoutFormat == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageWriteWithoutFormat == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageWriteWithoutFormat == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *prettify_VkPhysicalDeviceVulkan12Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderFloat16 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderFloat16 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderFloat16 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderInt8 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderInt8 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderInt8 == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: + { + VkPhysicalDeviceCustomBorderColorFeaturesEXT *prettify_VkPhysicalDeviceCustomBorderColorFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceCustomBorderColorFeaturesEXT->customBorderColors == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceCustomBorderColorFeaturesEXT->customBorderColors == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceCustomBorderColorFeaturesEXT::customBorderColors == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: + { + VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *prettify_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT->primitiveTopologyListRestart == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT->primitiveTopologyListRestart == VK_TRUE), "Unsupported feature condition: VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::primitiveTopologyListRestart == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: + { + VkPhysicalDeviceProvokingVertexFeaturesEXT *prettify_VkPhysicalDeviceProvokingVertexFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceProvokingVertexFeaturesEXT->provokingVertexLast == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProvokingVertexFeaturesEXT->provokingVertexLast == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceProvokingVertexFeaturesEXT::provokingVertexLast == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: + { + VkPhysicalDeviceIndexTypeUint8FeaturesEXT *prettify_VkPhysicalDeviceIndexTypeUint8FeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceIndexTypeUint8FeaturesEXT->indexTypeUint8 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceIndexTypeUint8FeaturesEXT->indexTypeUint8 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceIndexTypeUint8FeaturesEXT::indexTypeUint8 == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: + { + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR *prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR->vertexAttributeInstanceRateDivisor == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR->vertexAttributeInstanceRateDivisor == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::vertexAttributeInstanceRateDivisor == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + { + VkPhysicalDeviceSamplerYcbcrConversionFeatures *prettify_VkPhysicalDeviceSamplerYcbcrConversionFeatures = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceSamplerYcbcrConversionFeatures->samplerYcbcrConversion == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceSamplerYcbcrConversionFeatures->samplerYcbcrConversion == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceSamplerYcbcrConversionFeatures::samplerYcbcrConversion == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + { + VkPhysicalDeviceShaderFloat16Int8Features *prettify_VkPhysicalDeviceShaderFloat16Int8Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceShaderFloat16Int8Features->shaderFloat16 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceShaderFloat16Int8Features->shaderFloat16 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceShaderFloat16Int8Features::shaderFloat16 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceShaderFloat16Int8Features->shaderInt8 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceShaderFloat16Int8Features->shaderInt8 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceShaderFloat16Int8Features::shaderInt8 == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + { + VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *prettify_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures->shaderSubgroupExtendedTypes == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures->shaderSubgroupExtendedTypes == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::shaderSubgroupExtendedTypes == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + { + VkPhysicalDevice8BitStorageFeatures *prettify_VkPhysicalDevice8BitStorageFeatures = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDevice8BitStorageFeatures->storageBuffer8BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDevice8BitStorageFeatures->storageBuffer8BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDevice8BitStorageFeatures::storageBuffer8BitAccess == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + { + VkPhysicalDevice16BitStorageFeatures *prettify_VkPhysicalDevice16BitStorageFeatures = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDevice16BitStorageFeatures->storageBuffer16BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDevice16BitStorageFeatures->storageBuffer16BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDevice16BitStorageFeatures::storageBuffer16BitAccess == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - s->properties.limits.maxColorAttachments = 8; - s->properties.limits.maxPerStageDescriptorSampledImages = 128; - s->properties.limits.maxPerStageDescriptorSamplers = 128; - s->properties.limits.maxPerStageDescriptorStorageBuffers = 12; - s->properties.limits.maxPerStageDescriptorUniformBuffers = 13; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: { - VkPhysicalDeviceVulkan11Properties* s = static_cast(static_cast(p)); - s->subgroupSupportedOperations |= (VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->properties.limits.maxColorAttachments >= 8); - ret = ret && (s->properties.limits.maxPerStageDescriptorSampledImages >= 128); - ret = ret && (s->properties.limits.maxPerStageDescriptorSamplers >= 128); - ret = ret && (s->properties.limits.maxPerStageDescriptorStorageBuffers >= 12); - ret = ret && (s->properties.limits.maxPerStageDescriptorUniformBuffers >= 13); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: { - VkPhysicalDeviceVulkan11Properties* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->subgroupSupportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT))); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *s = static_cast(static_cast(p)); + s->properties.limits.maxColorAttachments = 8; + s->properties.limits.maxPerStageDescriptorSampledImages = 128; + s->properties.limits.maxPerStageDescriptorSamplers = 128; + s->properties.limits.maxPerStageDescriptorStorageBuffers = 12; + s->properties.limits.maxPerStageDescriptorUniformBuffers = 13; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + { + VkPhysicalDeviceVulkan11Properties *s = static_cast(static_cast(p)); + s->subgroupSupportedOperations |= (VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *prettify_VkPhysicalDeviceProperties2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxColorAttachments >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSampledImages >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSamplers >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 12); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 12), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageBuffers >= 12"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 13); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 13), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorUniformBuffers >= 13"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + { + VkPhysicalDeviceVulkan11Properties *prettify_VkPhysicalDeviceVulkan11Properties = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::subgroupSupportedOperations contains (VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT)"); + } + break; + default: + break; + } + return ret; + }}; static const VpFormatDesc formatDesc[] = { - { - VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, + {VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, }; static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr }; - VkPhysicalDeviceCustomBorderColorFeaturesEXT physicalDeviceCustomBorderColorFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, &physicalDeviceVulkan12Features }; - VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT physicalDevicePrimitiveTopologyListRestartFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, &physicalDeviceCustomBorderColorFeaturesEXT }; - VkPhysicalDeviceProvokingVertexFeaturesEXT physicalDeviceProvokingVertexFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, &physicalDevicePrimitiveTopologyListRestartFeaturesEXT }; - VkPhysicalDeviceIndexTypeUint8FeaturesEXT physicalDeviceIndexTypeUint8FeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, &physicalDeviceProvokingVertexFeaturesEXT }; - VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR physicalDeviceVertexAttributeDivisorFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, &physicalDeviceIndexTypeUint8FeaturesEXT }; - VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceVertexAttributeDivisorFeaturesKHR }; - VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures }; - VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures physicalDeviceShaderSubgroupExtendedTypesFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, &physicalDeviceShaderFloat16Int8Features }; - VkPhysicalDevice8BitStorageFeatures physicalDevice8BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, &physicalDeviceShaderSubgroupExtendedTypesFeatures }; - VkPhysicalDevice16BitStorageFeatures physicalDevice16BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, &physicalDevice8BitStorageFeatures }; - VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT physicalDevicePrimitivesGeneratedQueryFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, &physicalDevice16BitStorageFeatures }; - VkPhysicalDeviceLineRasterizationFeaturesEXT physicalDeviceLineRasterizationFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, &physicalDevicePrimitivesGeneratedQueryFeaturesEXT }; - VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG physicalDeviceRelaxedLineRasterizationFeaturesIMG{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, &physicalDeviceLineRasterizationFeaturesEXT }; - p->pNext = static_cast(static_cast(&physicalDeviceRelaxedLineRasterizationFeaturesIMG)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan11Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkFormatProperties3KHR formatProperties3KHR{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr }; - p->pNext = static_cast(static_cast(&formatProperties3KHR)); - pfnCb(p, pUser); - }, -}; -} //namespace MUST -namespace primitivesGeneratedQuery { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr}; + VkPhysicalDeviceCustomBorderColorFeaturesEXT physicalDeviceCustomBorderColorFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, &physicalDeviceVulkan12Features}; + VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT physicalDevicePrimitiveTopologyListRestartFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, &physicalDeviceCustomBorderColorFeaturesEXT}; + VkPhysicalDeviceProvokingVertexFeaturesEXT physicalDeviceProvokingVertexFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, &physicalDevicePrimitiveTopologyListRestartFeaturesEXT}; + VkPhysicalDeviceIndexTypeUint8FeaturesEXT physicalDeviceIndexTypeUint8FeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, &physicalDeviceProvokingVertexFeaturesEXT}; + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR physicalDeviceVertexAttributeDivisorFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, &physicalDeviceIndexTypeUint8FeaturesEXT}; + VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceVertexAttributeDivisorFeaturesKHR}; + VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures}; + VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures physicalDeviceShaderSubgroupExtendedTypesFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, &physicalDeviceShaderFloat16Int8Features}; + VkPhysicalDevice8BitStorageFeatures physicalDevice8BitStorageFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, &physicalDeviceShaderSubgroupExtendedTypesFeatures}; + VkPhysicalDevice16BitStorageFeatures physicalDevice16BitStorageFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, &physicalDevice8BitStorageFeatures}; + VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT physicalDevicePrimitivesGeneratedQueryFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, &physicalDevice16BitStorageFeatures}; + VkPhysicalDeviceLineRasterizationFeaturesEXT physicalDeviceLineRasterizationFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, &physicalDevicePrimitivesGeneratedQueryFeaturesEXT}; + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG physicalDeviceRelaxedLineRasterizationFeaturesIMG{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, &physicalDeviceLineRasterizationFeaturesEXT}; + p->pNext = static_cast(static_cast(&physicalDeviceRelaxedLineRasterizationFeaturesIMG)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan11Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkFormatProperties3KHR formatProperties3KHR{VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr}; + p->pNext = static_cast(static_cast(&formatProperties3KHR)); + pfnCb(p, pUser); + }, +}; +} // namespace MUST +namespace primitivesGeneratedQuery +{ + static const VkExtensionProperties deviceExtensions[] = { - VkExtensionProperties{ VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME, 1 }, + VkExtensionProperties{VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME, 1}, }; static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: { - VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* s = static_cast(static_cast(p)); - s->primitivesGeneratedQuery = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: { - VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* s = static_cast(static_cast(p)); - ret = ret && (s->primitivesGeneratedQuery == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: + { + VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *s = static_cast(static_cast(p)); + s->primitivesGeneratedQuery = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: + { + VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *prettify_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT->primitivesGeneratedQuery == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT->primitivesGeneratedQuery == VK_TRUE), "Unsupported feature condition: VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::primitivesGeneratedQuery == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; + [](VkBaseOutStructure *p) { + (void) p; }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } -}; + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr }; - VkPhysicalDeviceCustomBorderColorFeaturesEXT physicalDeviceCustomBorderColorFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, &physicalDeviceVulkan12Features }; - VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT physicalDevicePrimitiveTopologyListRestartFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, &physicalDeviceCustomBorderColorFeaturesEXT }; - VkPhysicalDeviceProvokingVertexFeaturesEXT physicalDeviceProvokingVertexFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, &physicalDevicePrimitiveTopologyListRestartFeaturesEXT }; - VkPhysicalDeviceIndexTypeUint8FeaturesEXT physicalDeviceIndexTypeUint8FeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, &physicalDeviceProvokingVertexFeaturesEXT }; - VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR physicalDeviceVertexAttributeDivisorFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, &physicalDeviceIndexTypeUint8FeaturesEXT }; - VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceVertexAttributeDivisorFeaturesKHR }; - VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures }; - VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures physicalDeviceShaderSubgroupExtendedTypesFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, &physicalDeviceShaderFloat16Int8Features }; - VkPhysicalDevice8BitStorageFeatures physicalDevice8BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, &physicalDeviceShaderSubgroupExtendedTypesFeatures }; - VkPhysicalDevice16BitStorageFeatures physicalDevice16BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, &physicalDevice8BitStorageFeatures }; - VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT physicalDevicePrimitivesGeneratedQueryFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, &physicalDevice16BitStorageFeatures }; - VkPhysicalDeviceLineRasterizationFeaturesEXT physicalDeviceLineRasterizationFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, &physicalDevicePrimitivesGeneratedQueryFeaturesEXT }; - VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG physicalDeviceRelaxedLineRasterizationFeaturesIMG{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, &physicalDeviceLineRasterizationFeaturesEXT }; - p->pNext = static_cast(static_cast(&physicalDeviceRelaxedLineRasterizationFeaturesIMG)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan11Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkFormatProperties3KHR formatProperties3KHR{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr }; - p->pNext = static_cast(static_cast(&formatProperties3KHR)); - pfnCb(p, pUser); - }, -}; -} //namespace primitivesGeneratedQuery -namespace pipelineStatisticsQuery { -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.pipelineStatisticsQuery = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.pipelineStatisticsQuery == VK_TRUE); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr}; + VkPhysicalDeviceCustomBorderColorFeaturesEXT physicalDeviceCustomBorderColorFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, &physicalDeviceVulkan12Features}; + VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT physicalDevicePrimitiveTopologyListRestartFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, &physicalDeviceCustomBorderColorFeaturesEXT}; + VkPhysicalDeviceProvokingVertexFeaturesEXT physicalDeviceProvokingVertexFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, &physicalDevicePrimitiveTopologyListRestartFeaturesEXT}; + VkPhysicalDeviceIndexTypeUint8FeaturesEXT physicalDeviceIndexTypeUint8FeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, &physicalDeviceProvokingVertexFeaturesEXT}; + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR physicalDeviceVertexAttributeDivisorFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, &physicalDeviceIndexTypeUint8FeaturesEXT}; + VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceVertexAttributeDivisorFeaturesKHR}; + VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures}; + VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures physicalDeviceShaderSubgroupExtendedTypesFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, &physicalDeviceShaderFloat16Int8Features}; + VkPhysicalDevice8BitStorageFeatures physicalDevice8BitStorageFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, &physicalDeviceShaderSubgroupExtendedTypesFeatures}; + VkPhysicalDevice16BitStorageFeatures physicalDevice16BitStorageFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, &physicalDevice8BitStorageFeatures}; + VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT physicalDevicePrimitivesGeneratedQueryFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, &physicalDevice16BitStorageFeatures}; + VkPhysicalDeviceLineRasterizationFeaturesEXT physicalDeviceLineRasterizationFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, &physicalDevicePrimitivesGeneratedQueryFeaturesEXT}; + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG physicalDeviceRelaxedLineRasterizationFeaturesIMG{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, &physicalDeviceLineRasterizationFeaturesEXT}; + p->pNext = static_cast(static_cast(&physicalDeviceRelaxedLineRasterizationFeaturesIMG)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan11Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkFormatProperties3KHR formatProperties3KHR{VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr}; + p->pNext = static_cast(static_cast(&formatProperties3KHR)); + pfnCb(p, pUser); + }, }; +} // namespace primitivesGeneratedQuery +namespace pipelineStatisticsQuery +{ + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.pipelineStatisticsQuery = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.pipelineStatisticsQuery == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.pipelineStatisticsQuery == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.pipelineStatisticsQuery == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; + [](VkBaseOutStructure *p) { + (void) p; }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } -}; + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr }; - VkPhysicalDeviceCustomBorderColorFeaturesEXT physicalDeviceCustomBorderColorFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, &physicalDeviceVulkan12Features }; - VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT physicalDevicePrimitiveTopologyListRestartFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, &physicalDeviceCustomBorderColorFeaturesEXT }; - VkPhysicalDeviceProvokingVertexFeaturesEXT physicalDeviceProvokingVertexFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, &physicalDevicePrimitiveTopologyListRestartFeaturesEXT }; - VkPhysicalDeviceIndexTypeUint8FeaturesEXT physicalDeviceIndexTypeUint8FeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, &physicalDeviceProvokingVertexFeaturesEXT }; - VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR physicalDeviceVertexAttributeDivisorFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, &physicalDeviceIndexTypeUint8FeaturesEXT }; - VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceVertexAttributeDivisorFeaturesKHR }; - VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures }; - VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures physicalDeviceShaderSubgroupExtendedTypesFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, &physicalDeviceShaderFloat16Int8Features }; - VkPhysicalDevice8BitStorageFeatures physicalDevice8BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, &physicalDeviceShaderSubgroupExtendedTypesFeatures }; - VkPhysicalDevice16BitStorageFeatures physicalDevice16BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, &physicalDevice8BitStorageFeatures }; - VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT physicalDevicePrimitivesGeneratedQueryFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, &physicalDevice16BitStorageFeatures }; - VkPhysicalDeviceLineRasterizationFeaturesEXT physicalDeviceLineRasterizationFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, &physicalDevicePrimitivesGeneratedQueryFeaturesEXT }; - VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG physicalDeviceRelaxedLineRasterizationFeaturesIMG{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, &physicalDeviceLineRasterizationFeaturesEXT }; - p->pNext = static_cast(static_cast(&physicalDeviceRelaxedLineRasterizationFeaturesIMG)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan11Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkFormatProperties3KHR formatProperties3KHR{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr }; - p->pNext = static_cast(static_cast(&formatProperties3KHR)); - pfnCb(p, pUser); - }, -}; -} //namespace pipelineStatisticsQuery -namespace swBresenhamLines { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr}; + VkPhysicalDeviceCustomBorderColorFeaturesEXT physicalDeviceCustomBorderColorFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, &physicalDeviceVulkan12Features}; + VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT physicalDevicePrimitiveTopologyListRestartFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, &physicalDeviceCustomBorderColorFeaturesEXT}; + VkPhysicalDeviceProvokingVertexFeaturesEXT physicalDeviceProvokingVertexFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, &physicalDevicePrimitiveTopologyListRestartFeaturesEXT}; + VkPhysicalDeviceIndexTypeUint8FeaturesEXT physicalDeviceIndexTypeUint8FeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, &physicalDeviceProvokingVertexFeaturesEXT}; + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR physicalDeviceVertexAttributeDivisorFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, &physicalDeviceIndexTypeUint8FeaturesEXT}; + VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceVertexAttributeDivisorFeaturesKHR}; + VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures}; + VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures physicalDeviceShaderSubgroupExtendedTypesFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, &physicalDeviceShaderFloat16Int8Features}; + VkPhysicalDevice8BitStorageFeatures physicalDevice8BitStorageFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, &physicalDeviceShaderSubgroupExtendedTypesFeatures}; + VkPhysicalDevice16BitStorageFeatures physicalDevice16BitStorageFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, &physicalDevice8BitStorageFeatures}; + VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT physicalDevicePrimitivesGeneratedQueryFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, &physicalDevice16BitStorageFeatures}; + VkPhysicalDeviceLineRasterizationFeaturesEXT physicalDeviceLineRasterizationFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, &physicalDevicePrimitivesGeneratedQueryFeaturesEXT}; + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG physicalDeviceRelaxedLineRasterizationFeaturesIMG{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, &physicalDeviceLineRasterizationFeaturesEXT}; + p->pNext = static_cast(static_cast(&physicalDeviceRelaxedLineRasterizationFeaturesIMG)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan11Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkFormatProperties3KHR formatProperties3KHR{VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr}; + p->pNext = static_cast(static_cast(&formatProperties3KHR)); + pfnCb(p, pUser); + }, +}; +} // namespace pipelineStatisticsQuery +namespace swBresenhamLines +{ + static const VkExtensionProperties deviceExtensions[] = { - VkExtensionProperties{ VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME, 1 }, + VkExtensionProperties{VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME, 1}, }; static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: { - VkPhysicalDeviceLineRasterizationFeaturesEXT* s = static_cast(static_cast(p)); - s->bresenhamLines = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: { - VkPhysicalDeviceLineRasterizationFeaturesEXT* s = static_cast(static_cast(p)); - ret = ret && (s->bresenhamLines == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: + { + VkPhysicalDeviceLineRasterizationFeaturesEXT *s = static_cast(static_cast(p)); + s->bresenhamLines = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: + { + VkPhysicalDeviceLineRasterizationFeaturesEXT *prettify_VkPhysicalDeviceLineRasterizationFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceLineRasterizationFeaturesEXT->bresenhamLines == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceLineRasterizationFeaturesEXT->bresenhamLines == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceLineRasterizationFeaturesEXT::bresenhamLines == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; + [](VkBaseOutStructure *p) { + (void) p; }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } -}; + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr }; - VkPhysicalDeviceCustomBorderColorFeaturesEXT physicalDeviceCustomBorderColorFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, &physicalDeviceVulkan12Features }; - VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT physicalDevicePrimitiveTopologyListRestartFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, &physicalDeviceCustomBorderColorFeaturesEXT }; - VkPhysicalDeviceProvokingVertexFeaturesEXT physicalDeviceProvokingVertexFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, &physicalDevicePrimitiveTopologyListRestartFeaturesEXT }; - VkPhysicalDeviceIndexTypeUint8FeaturesEXT physicalDeviceIndexTypeUint8FeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, &physicalDeviceProvokingVertexFeaturesEXT }; - VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR physicalDeviceVertexAttributeDivisorFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, &physicalDeviceIndexTypeUint8FeaturesEXT }; - VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceVertexAttributeDivisorFeaturesKHR }; - VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures }; - VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures physicalDeviceShaderSubgroupExtendedTypesFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, &physicalDeviceShaderFloat16Int8Features }; - VkPhysicalDevice8BitStorageFeatures physicalDevice8BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, &physicalDeviceShaderSubgroupExtendedTypesFeatures }; - VkPhysicalDevice16BitStorageFeatures physicalDevice16BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, &physicalDevice8BitStorageFeatures }; - VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT physicalDevicePrimitivesGeneratedQueryFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, &physicalDevice16BitStorageFeatures }; - VkPhysicalDeviceLineRasterizationFeaturesEXT physicalDeviceLineRasterizationFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, &physicalDevicePrimitivesGeneratedQueryFeaturesEXT }; - VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG physicalDeviceRelaxedLineRasterizationFeaturesIMG{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, &physicalDeviceLineRasterizationFeaturesEXT }; - p->pNext = static_cast(static_cast(&physicalDeviceRelaxedLineRasterizationFeaturesIMG)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan11Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkFormatProperties3KHR formatProperties3KHR{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr }; - p->pNext = static_cast(static_cast(&formatProperties3KHR)); - pfnCb(p, pUser); - }, -}; -} //namespace swBresenhamLines -namespace hwBresenhamLines { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr}; + VkPhysicalDeviceCustomBorderColorFeaturesEXT physicalDeviceCustomBorderColorFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, &physicalDeviceVulkan12Features}; + VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT physicalDevicePrimitiveTopologyListRestartFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, &physicalDeviceCustomBorderColorFeaturesEXT}; + VkPhysicalDeviceProvokingVertexFeaturesEXT physicalDeviceProvokingVertexFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, &physicalDevicePrimitiveTopologyListRestartFeaturesEXT}; + VkPhysicalDeviceIndexTypeUint8FeaturesEXT physicalDeviceIndexTypeUint8FeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, &physicalDeviceProvokingVertexFeaturesEXT}; + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR physicalDeviceVertexAttributeDivisorFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, &physicalDeviceIndexTypeUint8FeaturesEXT}; + VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceVertexAttributeDivisorFeaturesKHR}; + VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures}; + VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures physicalDeviceShaderSubgroupExtendedTypesFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, &physicalDeviceShaderFloat16Int8Features}; + VkPhysicalDevice8BitStorageFeatures physicalDevice8BitStorageFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, &physicalDeviceShaderSubgroupExtendedTypesFeatures}; + VkPhysicalDevice16BitStorageFeatures physicalDevice16BitStorageFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, &physicalDevice8BitStorageFeatures}; + VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT physicalDevicePrimitivesGeneratedQueryFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, &physicalDevice16BitStorageFeatures}; + VkPhysicalDeviceLineRasterizationFeaturesEXT physicalDeviceLineRasterizationFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, &physicalDevicePrimitivesGeneratedQueryFeaturesEXT}; + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG physicalDeviceRelaxedLineRasterizationFeaturesIMG{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, &physicalDeviceLineRasterizationFeaturesEXT}; + p->pNext = static_cast(static_cast(&physicalDeviceRelaxedLineRasterizationFeaturesIMG)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan11Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkFormatProperties3KHR formatProperties3KHR{VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr}; + p->pNext = static_cast(static_cast(&formatProperties3KHR)); + pfnCb(p, pUser); + }, +}; +} // namespace swBresenhamLines +namespace hwBresenhamLines +{ + static const VkExtensionProperties deviceExtensions[] = { - VkExtensionProperties{ VK_IMG_RELAXED_LINE_RASTERIZATION_EXTENSION_NAME, 1 }, + VkExtensionProperties{VK_IMG_RELAXED_LINE_RASTERIZATION_EXTENSION_NAME, 1}, }; static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: { - VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* s = static_cast(static_cast(p)); - s->relaxedLineRasterization = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: { - VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* s = static_cast(static_cast(p)); - ret = ret && (s->relaxedLineRasterization == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + { + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *s = static_cast(static_cast(p)); + s->relaxedLineRasterization = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + { + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *prettify_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG->relaxedLineRasterization == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG->relaxedLineRasterization == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG::relaxedLineRasterization == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; + [](VkBaseOutStructure *p) { + (void) p; }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } -}; + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr }; - VkPhysicalDeviceCustomBorderColorFeaturesEXT physicalDeviceCustomBorderColorFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, &physicalDeviceVulkan12Features }; - VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT physicalDevicePrimitiveTopologyListRestartFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, &physicalDeviceCustomBorderColorFeaturesEXT }; - VkPhysicalDeviceProvokingVertexFeaturesEXT physicalDeviceProvokingVertexFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, &physicalDevicePrimitiveTopologyListRestartFeaturesEXT }; - VkPhysicalDeviceIndexTypeUint8FeaturesEXT physicalDeviceIndexTypeUint8FeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, &physicalDeviceProvokingVertexFeaturesEXT }; - VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR physicalDeviceVertexAttributeDivisorFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, &physicalDeviceIndexTypeUint8FeaturesEXT }; - VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceVertexAttributeDivisorFeaturesKHR }; - VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures }; - VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures physicalDeviceShaderSubgroupExtendedTypesFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, &physicalDeviceShaderFloat16Int8Features }; - VkPhysicalDevice8BitStorageFeatures physicalDevice8BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, &physicalDeviceShaderSubgroupExtendedTypesFeatures }; - VkPhysicalDevice16BitStorageFeatures physicalDevice16BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, &physicalDevice8BitStorageFeatures }; - VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT physicalDevicePrimitivesGeneratedQueryFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, &physicalDevice16BitStorageFeatures }; - VkPhysicalDeviceLineRasterizationFeaturesEXT physicalDeviceLineRasterizationFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, &physicalDevicePrimitivesGeneratedQueryFeaturesEXT }; - VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG physicalDeviceRelaxedLineRasterizationFeaturesIMG{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, &physicalDeviceLineRasterizationFeaturesEXT }; - p->pNext = static_cast(static_cast(&physicalDeviceRelaxedLineRasterizationFeaturesIMG)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan11Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkFormatProperties3KHR formatProperties3KHR{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr }; - p->pNext = static_cast(static_cast(&formatProperties3KHR)); - pfnCb(p, pUser); - }, -}; -} //namespace hwBresenhamLines -} // namespace VP_ANDROID_15_MINIMUMS -#endif // VP_ANDROID_15_minimums + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr}; + VkPhysicalDeviceCustomBorderColorFeaturesEXT physicalDeviceCustomBorderColorFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, &physicalDeviceVulkan12Features}; + VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT physicalDevicePrimitiveTopologyListRestartFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, &physicalDeviceCustomBorderColorFeaturesEXT}; + VkPhysicalDeviceProvokingVertexFeaturesEXT physicalDeviceProvokingVertexFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, &physicalDevicePrimitiveTopologyListRestartFeaturesEXT}; + VkPhysicalDeviceIndexTypeUint8FeaturesEXT physicalDeviceIndexTypeUint8FeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, &physicalDeviceProvokingVertexFeaturesEXT}; + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR physicalDeviceVertexAttributeDivisorFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, &physicalDeviceIndexTypeUint8FeaturesEXT}; + VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceVertexAttributeDivisorFeaturesKHR}; + VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures}; + VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures physicalDeviceShaderSubgroupExtendedTypesFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, &physicalDeviceShaderFloat16Int8Features}; + VkPhysicalDevice8BitStorageFeatures physicalDevice8BitStorageFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, &physicalDeviceShaderSubgroupExtendedTypesFeatures}; + VkPhysicalDevice16BitStorageFeatures physicalDevice16BitStorageFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, &physicalDevice8BitStorageFeatures}; + VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT physicalDevicePrimitivesGeneratedQueryFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, &physicalDevice16BitStorageFeatures}; + VkPhysicalDeviceLineRasterizationFeaturesEXT physicalDeviceLineRasterizationFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, &physicalDevicePrimitivesGeneratedQueryFeaturesEXT}; + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG physicalDeviceRelaxedLineRasterizationFeaturesIMG{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, &physicalDeviceLineRasterizationFeaturesEXT}; + p->pNext = static_cast(static_cast(&physicalDeviceRelaxedLineRasterizationFeaturesIMG)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan11Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkFormatProperties3KHR formatProperties3KHR{VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr}; + p->pNext = static_cast(static_cast(&formatProperties3KHR)); + pfnCb(p, pUser); + }, +}; +} // namespace hwBresenhamLines +} // namespace blocks +} // namespace VP_ANDROID_15_MINIMUMS +#endif // VP_ANDROID_15_minimums #ifdef VP_ANDROID_16_minimums -namespace VP_ANDROID_16_MINIMUMS { +namespace VP_ANDROID_16_MINIMUMS +{ static const VkStructureType featureStructTypes[] = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, @@ -1288,336 +2003,419 @@ static const VkStructureType propertyStructTypes[] = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, }; -namespace MUST { +namespace blocks +{ +namespace MUST +{ + static const VkExtensionProperties deviceExtensions[] = { - VkExtensionProperties{ VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_8BIT_STORAGE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_MAINTENANCE_6_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_MAP_MEMORY_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME, 1 }, + VkExtensionProperties{VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_8BIT_STORAGE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_6_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAP_MEMORY_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME, 1}, }; static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.depthClamp = VK_TRUE; - s->features.fullDrawIndexUint32 = VK_TRUE; - s->features.shaderInt16 = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - s->descriptorBindingPartiallyBound = VK_TRUE; - s->descriptorBindingUpdateUnusedWhilePending = VK_TRUE; - s->descriptorBindingVariableDescriptorCount = VK_TRUE; - s->descriptorIndexing = VK_TRUE; - s->runtimeDescriptorArray = VK_TRUE; - s->samplerMirrorClampToEdge = VK_TRUE; - s->scalarBlockLayout = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: { - VkPhysicalDeviceProtectedMemoryFeatures* s = static_cast(static_cast(p)); - s->protectedMemory = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: { - VkPhysicalDeviceShaderIntegerDotProductFeatures* s = static_cast(static_cast(p)); - s->shaderIntegerDotProduct = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: { - VkPhysicalDeviceTransformFeedbackFeaturesEXT* s = static_cast(static_cast(p)); - s->transformFeedback = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: { - VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* s = static_cast(static_cast(p)); - s->image2DViewOf3D = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: { - VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* s = static_cast(static_cast(p)); - s->shaderSubgroupUniformControlFlow = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.depthClamp == VK_TRUE); - ret = ret && (s->features.fullDrawIndexUint32 == VK_TRUE); - ret = ret && (s->features.shaderInt16 == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - ret = ret && (s->descriptorBindingPartiallyBound == VK_TRUE); - ret = ret && (s->descriptorBindingUpdateUnusedWhilePending == VK_TRUE); - ret = ret && (s->descriptorBindingVariableDescriptorCount == VK_TRUE); - ret = ret && (s->descriptorIndexing == VK_TRUE); - ret = ret && (s->runtimeDescriptorArray == VK_TRUE); - ret = ret && (s->samplerMirrorClampToEdge == VK_TRUE); - ret = ret && (s->scalarBlockLayout == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: { - VkPhysicalDeviceProtectedMemoryFeatures* s = static_cast(static_cast(p)); - ret = ret && (s->protectedMemory == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: { - VkPhysicalDeviceShaderIntegerDotProductFeatures* s = static_cast(static_cast(p)); - ret = ret && (s->shaderIntegerDotProduct == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: { - VkPhysicalDeviceTransformFeedbackFeaturesEXT* s = static_cast(static_cast(p)); - ret = ret && (s->transformFeedback == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: { - VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* s = static_cast(static_cast(p)); - ret = ret && (s->image2DViewOf3D == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: { - VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* s = static_cast(static_cast(p)); - ret = ret && (s->shaderSubgroupUniformControlFlow == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.fullDrawIndexUint32 = VK_TRUE; + s->features.shaderInt16 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *s = static_cast(static_cast(p)); + s->samplerMirrorClampToEdge = VK_TRUE; + s->scalarBlockLayout = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + { + VkPhysicalDeviceProtectedMemoryFeatures *s = static_cast(static_cast(p)); + s->protectedMemory = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + { + VkPhysicalDeviceShaderIntegerDotProductFeatures *s = static_cast(static_cast(p)); + s->shaderIntegerDotProduct = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + { + VkPhysicalDeviceTransformFeedbackFeaturesEXT *s = static_cast(static_cast(p)); + s->transformFeedback = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: + { + VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *s = static_cast(static_cast(p)); + s->image2DViewOf3D = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: + { + VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *s = static_cast(static_cast(p)); + s->shaderSubgroupUniformControlFlow = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fullDrawIndexUint32 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderInt16 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderInt16 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderInt16 == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *prettify_VkPhysicalDeviceVulkan12Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->samplerMirrorClampToEdge == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->samplerMirrorClampToEdge == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::samplerMirrorClampToEdge == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->scalarBlockLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->scalarBlockLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::scalarBlockLayout == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + { + VkPhysicalDeviceProtectedMemoryFeatures *prettify_VkPhysicalDeviceProtectedMemoryFeatures = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceProtectedMemoryFeatures->protectedMemory == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProtectedMemoryFeatures->protectedMemory == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceProtectedMemoryFeatures::protectedMemory == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + { + VkPhysicalDeviceShaderIntegerDotProductFeatures *prettify_VkPhysicalDeviceShaderIntegerDotProductFeatures = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceShaderIntegerDotProductFeatures->shaderIntegerDotProduct == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceShaderIntegerDotProductFeatures->shaderIntegerDotProduct == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceShaderIntegerDotProductFeatures::shaderIntegerDotProduct == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + { + VkPhysicalDeviceTransformFeedbackFeaturesEXT *prettify_VkPhysicalDeviceTransformFeedbackFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceTransformFeedbackFeaturesEXT->transformFeedback == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceTransformFeedbackFeaturesEXT->transformFeedback == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceTransformFeedbackFeaturesEXT::transformFeedback == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: + { + VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *prettify_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT->image2DViewOf3D == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT->image2DViewOf3D == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceImage2DViewOf3DFeaturesEXT::image2DViewOf3D == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: + { + VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *prettify_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR->shaderSubgroupUniformControlFlow == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR->shaderSubgroupUniformControlFlow == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::shaderSubgroupUniformControlFlow == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - s->properties.limits.bufferImageGranularity = 4096; - s->properties.limits.lineWidthGranularity = 0.5f; - s->properties.limits.maxBoundDescriptorSets = 7; - s->properties.limits.maxColorAttachments = 8; - s->properties.limits.maxComputeWorkGroupInvocations = 256; - s->properties.limits.maxComputeWorkGroupSize[0] = 256; - s->properties.limits.maxComputeWorkGroupSize[1] = 256; - s->properties.limits.maxComputeWorkGroupSize[2] = 64; - s->properties.limits.maxDescriptorSetStorageBuffers = 96; - s->properties.limits.maxDescriptorSetStorageImages = 144; - s->properties.limits.maxDescriptorSetUniformBuffers = 90; - s->properties.limits.maxFragmentCombinedOutputResources = 16; - s->properties.limits.maxImageArrayLayers = 2048; - s->properties.limits.maxImageDimension1D = 8192; - s->properties.limits.maxImageDimension2D = 8192; - s->properties.limits.maxImageDimensionCube = 8192; - s->properties.limits.maxPerStageDescriptorUniformBuffers = 15; - s->properties.limits.maxPerStageResources = 200; - s->properties.limits.maxPushConstantsSize = 256; - s->properties.limits.maxSamplerLodBias = 14; - s->properties.limits.maxUniformBufferRange = 65536; - s->properties.limits.maxVertexOutputComponents = 128; - s->properties.limits.mipmapPrecisionBits = 6; - s->properties.limits.pointSizeGranularity = 0.125f; - s->properties.limits.standardSampleLocations = VK_TRUE; - s->properties.limits.subTexelPrecisionBits = 8; - s->properties.limits.timestampComputeAndGraphics = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: { - VkPhysicalDeviceFloatControlsProperties* s = static_cast(static_cast(p)); - s->shaderSignedZeroInfNanPreserveFloat16 = VK_TRUE; - s->shaderSignedZeroInfNanPreserveFloat32 = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: { - VkPhysicalDeviceVulkan11Properties* s = static_cast(static_cast(p)); - s->subgroupSupportedStages |= (VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->properties.limits.bufferImageGranularity <= 4096); - ret = ret && ((4096 % s->properties.limits.bufferImageGranularity) == 0); - ret = ret && (s->properties.limits.lineWidthGranularity <= 0.5); - ret = ret && (isMultiple(0.5, s->properties.limits.lineWidthGranularity)); - ret = ret && (s->properties.limits.maxBoundDescriptorSets >= 7); - ret = ret && (s->properties.limits.maxColorAttachments >= 8); - ret = ret && (s->properties.limits.maxComputeWorkGroupInvocations >= 256); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[0] >= 256); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[1] >= 256); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[2] >= 64); - ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffers >= 96); - ret = ret && (s->properties.limits.maxDescriptorSetStorageImages >= 144); - ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffers >= 90); - ret = ret && (s->properties.limits.maxFragmentCombinedOutputResources >= 16); - ret = ret && (s->properties.limits.maxImageArrayLayers >= 2048); - ret = ret && (s->properties.limits.maxImageDimension1D >= 8192); - ret = ret && (s->properties.limits.maxImageDimension2D >= 8192); - ret = ret && (s->properties.limits.maxImageDimensionCube >= 8192); - ret = ret && (s->properties.limits.maxPerStageDescriptorUniformBuffers >= 15); - ret = ret && (s->properties.limits.maxPerStageResources >= 200); - ret = ret && (s->properties.limits.maxPushConstantsSize >= 256); - ret = ret && (s->properties.limits.maxSamplerLodBias >= 14); - ret = ret && (s->properties.limits.maxUniformBufferRange >= 65536); - ret = ret && (s->properties.limits.maxVertexOutputComponents >= 128); - ret = ret && (s->properties.limits.mipmapPrecisionBits >= 6); - ret = ret && (s->properties.limits.pointSizeGranularity <= 0.125); - ret = ret && (isMultiple(0.125, s->properties.limits.pointSizeGranularity)); - ret = ret && (s->properties.limits.standardSampleLocations == VK_TRUE); - ret = ret && (s->properties.limits.subTexelPrecisionBits >= 8); - ret = ret && (vpCheckFlags(s->properties.limits.timestampComputeAndGraphics, VK_TRUE)); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: { - VkPhysicalDeviceFloatControlsProperties* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->shaderSignedZeroInfNanPreserveFloat16, VK_TRUE)); - ret = ret && (vpCheckFlags(s->shaderSignedZeroInfNanPreserveFloat32, VK_TRUE)); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: { - VkPhysicalDeviceVulkan11Properties* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->subgroupSupportedStages, (VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT))); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *s = static_cast(static_cast(p)); + s->properties.limits.bufferImageGranularity = 4096; + s->properties.limits.lineWidthGranularity = 0.5f; + s->properties.limits.maxColorAttachments = 8; + s->properties.limits.maxComputeWorkGroupInvocations = 256; + s->properties.limits.maxComputeWorkGroupSize[0] = 256; + s->properties.limits.maxComputeWorkGroupSize[1] = 256; + s->properties.limits.maxComputeWorkGroupSize[2] = 64; + s->properties.limits.maxDescriptorSetStorageBuffers = 96; + s->properties.limits.maxDescriptorSetUniformBuffers = 90; + s->properties.limits.maxFragmentCombinedOutputResources = 16; + s->properties.limits.maxImageArrayLayers = 2048; + s->properties.limits.maxImageDimension1D = 8192; + s->properties.limits.maxImageDimension2D = 8192; + s->properties.limits.maxImageDimensionCube = 8192; + s->properties.limits.maxPerStageDescriptorUniformBuffers = 15; + s->properties.limits.maxPerStageResources = 200; + s->properties.limits.maxSamplerLodBias = 14; + s->properties.limits.maxUniformBufferRange = 65536; + s->properties.limits.maxVertexOutputComponents = 72; + s->properties.limits.mipmapPrecisionBits = 6; + s->properties.limits.pointSizeGranularity = 0.125f; + s->properties.limits.standardSampleLocations = VK_TRUE; + s->properties.limits.subTexelPrecisionBits = 8; + s->properties.limits.timestampComputeAndGraphics = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: + { + VkPhysicalDeviceFloatControlsProperties *s = static_cast(static_cast(p)); + s->shaderSignedZeroInfNanPreserveFloat16 = VK_TRUE; + s->shaderSignedZeroInfNanPreserveFloat32 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + { + VkPhysicalDeviceVulkan11Properties *s = static_cast(static_cast(p)); + s->subgroupSupportedStages |= (VK_SHADER_STAGE_COMPUTE_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *prettify_VkPhysicalDeviceProperties2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity <= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity <= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.bufferImageGranularity <= 4096"); + ret = ret && ((4096 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0); + VP_DEBUG_COND_MSG(!((4096 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0), "Unsupported properties condition: (4096 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity <= 0.5); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity <= 0.5), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthGranularity <= 0.5"); + ret = ret && (isMultiple(0.5, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)); + VP_DEBUG_COND_MSG(!(isMultiple(0.5, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)), "Unsupported properties condition: isMultiple(0.5, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxColorAttachments >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupInvocations >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[0] >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[1] >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[2] >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 96); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 96), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffers >= 96"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 90); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 90), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffers >= 90"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentCombinedOutputResources >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageArrayLayers >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 8192); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 8192), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension1D >= 8192"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 8192); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 8192), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension2D >= 8192"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 8192); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 8192), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimensionCube >= 8192"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 15); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 15), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorUniformBuffers >= 15"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 200); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 200), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageResources >= 200"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 14); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 14), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerLodBias >= 14"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 65536); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 65536), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxUniformBufferRange >= 65536"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 72); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 72), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexOutputComponents >= 72"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 6); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 6), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.mipmapPrecisionBits >= 6"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 0.125); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 0.125), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeGranularity <= 0.125"); + ret = ret && (isMultiple(0.125, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)); + VP_DEBUG_COND_MSG(!(isMultiple(0.125, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)), "Unsupported properties condition: isMultiple(0.125, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.standardSampleLocations >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.standardSampleLocations >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.standardSampleLocations >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subTexelPrecisionBits >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.timestampComputeAndGraphics >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.timestampComputeAndGraphics >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.timestampComputeAndGraphics >= VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: + { + VkPhysicalDeviceFloatControlsProperties *prettify_VkPhysicalDeviceFloatControlsProperties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFloatControlsProperties->shaderSignedZeroInfNanPreserveFloat16 >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFloatControlsProperties->shaderSignedZeroInfNanPreserveFloat16 >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceFloatControlsProperties::shaderSignedZeroInfNanPreserveFloat16 >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFloatControlsProperties->shaderSignedZeroInfNanPreserveFloat32 >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFloatControlsProperties->shaderSignedZeroInfNanPreserveFloat32 >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceFloatControlsProperties::shaderSignedZeroInfNanPreserveFloat32 >= VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + { + VkPhysicalDeviceVulkan11Properties *prettify_VkPhysicalDeviceVulkan11Properties = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedStages, (VK_SHADER_STAGE_COMPUTE_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedStages, (VK_SHADER_STAGE_COMPUTE_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::subgroupSupportedStages contains (VK_SHADER_STAGE_COMPUTE_BIT)"); + } + break; + default: + break; + } + return ret; + }}; static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr }; - VkPhysicalDeviceProtectedMemoryFeatures physicalDeviceProtectedMemoryFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, &physicalDeviceVulkan12Features }; - VkPhysicalDeviceShaderIntegerDotProductFeatures physicalDeviceShaderIntegerDotProductFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, &physicalDeviceProtectedMemoryFeatures }; - VkPhysicalDeviceTransformFeedbackFeaturesEXT physicalDeviceTransformFeedbackFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, &physicalDeviceShaderIntegerDotProductFeatures }; - VkPhysicalDeviceImage2DViewOf3DFeaturesEXT physicalDeviceImage2DViewOf3DFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, &physicalDeviceTransformFeedbackFeaturesEXT }; - VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, &physicalDeviceImage2DViewOf3DFeaturesEXT }; - p->pNext = static_cast(static_cast(&physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceFloatControlsProperties physicalDeviceFloatControlsProperties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, &physicalDeviceFloatControlsProperties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan11Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, -}; -} //namespace MUST -namespace multisampledToSingleSampled { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr}; + VkPhysicalDeviceProtectedMemoryFeatures physicalDeviceProtectedMemoryFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, &physicalDeviceVulkan12Features}; + VkPhysicalDeviceShaderIntegerDotProductFeatures physicalDeviceShaderIntegerDotProductFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, &physicalDeviceProtectedMemoryFeatures}; + VkPhysicalDeviceTransformFeedbackFeaturesEXT physicalDeviceTransformFeedbackFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, &physicalDeviceShaderIntegerDotProductFeatures}; + VkPhysicalDeviceImage2DViewOf3DFeaturesEXT physicalDeviceImage2DViewOf3DFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, &physicalDeviceTransformFeedbackFeaturesEXT}; + VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, &physicalDeviceImage2DViewOf3DFeaturesEXT}; + p->pNext = static_cast(static_cast(&physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceFloatControlsProperties physicalDeviceFloatControlsProperties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, &physicalDeviceFloatControlsProperties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan11Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); + }, +}; +} // namespace MUST +namespace multisampledToSingleSampled +{ + static const VkExtensionProperties deviceExtensions[] = { - VkExtensionProperties{ VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME, 1 }, + VkExtensionProperties{VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME, 1}, }; static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; + [](VkBaseOutStructure *p) { + (void) p; }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } -}; + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; + [](VkBaseOutStructure *p) { + (void) p; }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } -}; + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr }; - VkPhysicalDeviceProtectedMemoryFeatures physicalDeviceProtectedMemoryFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, &physicalDeviceVulkan12Features }; - VkPhysicalDeviceShaderIntegerDotProductFeatures physicalDeviceShaderIntegerDotProductFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, &physicalDeviceProtectedMemoryFeatures }; - VkPhysicalDeviceTransformFeedbackFeaturesEXT physicalDeviceTransformFeedbackFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, &physicalDeviceShaderIntegerDotProductFeatures }; - VkPhysicalDeviceImage2DViewOf3DFeaturesEXT physicalDeviceImage2DViewOf3DFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, &physicalDeviceTransformFeedbackFeaturesEXT }; - VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, &physicalDeviceImage2DViewOf3DFeaturesEXT }; - p->pNext = static_cast(static_cast(&physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceFloatControlsProperties physicalDeviceFloatControlsProperties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, &physicalDeviceFloatControlsProperties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan11Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, -}; -} //namespace multisampledToSingleSampled -namespace shaderStencilExport { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr}; + VkPhysicalDeviceProtectedMemoryFeatures physicalDeviceProtectedMemoryFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, &physicalDeviceVulkan12Features}; + VkPhysicalDeviceShaderIntegerDotProductFeatures physicalDeviceShaderIntegerDotProductFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, &physicalDeviceProtectedMemoryFeatures}; + VkPhysicalDeviceTransformFeedbackFeaturesEXT physicalDeviceTransformFeedbackFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, &physicalDeviceShaderIntegerDotProductFeatures}; + VkPhysicalDeviceImage2DViewOf3DFeaturesEXT physicalDeviceImage2DViewOf3DFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, &physicalDeviceTransformFeedbackFeaturesEXT}; + VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, &physicalDeviceImage2DViewOf3DFeaturesEXT}; + p->pNext = static_cast(static_cast(&physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceFloatControlsProperties physicalDeviceFloatControlsProperties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, &physicalDeviceFloatControlsProperties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan11Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); + }, +}; +} // namespace multisampledToSingleSampled +namespace shaderStencilExport +{ + static const VkExtensionProperties deviceExtensions[] = { - VkExtensionProperties{ VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME, 1 }, + VkExtensionProperties{VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME, 1}, }; static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; + [](VkBaseOutStructure *p) { + (void) p; }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } -}; + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; + [](VkBaseOutStructure *p) { + (void) p; }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } -}; + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr }; - VkPhysicalDeviceProtectedMemoryFeatures physicalDeviceProtectedMemoryFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, &physicalDeviceVulkan12Features }; - VkPhysicalDeviceShaderIntegerDotProductFeatures physicalDeviceShaderIntegerDotProductFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, &physicalDeviceProtectedMemoryFeatures }; - VkPhysicalDeviceTransformFeedbackFeaturesEXT physicalDeviceTransformFeedbackFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, &physicalDeviceShaderIntegerDotProductFeatures }; - VkPhysicalDeviceImage2DViewOf3DFeaturesEXT physicalDeviceImage2DViewOf3DFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, &physicalDeviceTransformFeedbackFeaturesEXT }; - VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, &physicalDeviceImage2DViewOf3DFeaturesEXT }; - p->pNext = static_cast(static_cast(&physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceFloatControlsProperties physicalDeviceFloatControlsProperties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, &physicalDeviceFloatControlsProperties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan11Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr}; + VkPhysicalDeviceProtectedMemoryFeatures physicalDeviceProtectedMemoryFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, &physicalDeviceVulkan12Features}; + VkPhysicalDeviceShaderIntegerDotProductFeatures physicalDeviceShaderIntegerDotProductFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, &physicalDeviceProtectedMemoryFeatures}; + VkPhysicalDeviceTransformFeedbackFeaturesEXT physicalDeviceTransformFeedbackFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, &physicalDeviceShaderIntegerDotProductFeatures}; + VkPhysicalDeviceImage2DViewOf3DFeaturesEXT physicalDeviceImage2DViewOf3DFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, &physicalDeviceTransformFeedbackFeaturesEXT}; + VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, &physicalDeviceImage2DViewOf3DFeaturesEXT}; + p->pNext = static_cast(static_cast(&physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceFloatControlsProperties physicalDeviceFloatControlsProperties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, &physicalDeviceFloatControlsProperties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan11Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, }; -} //namespace shaderStencilExport -} // namespace VP_ANDROID_16_MINIMUMS -#endif // VP_ANDROID_16_minimums +} // namespace shaderStencilExport +} // namespace blocks +} // namespace VP_ANDROID_16_MINIMUMS +#endif // VP_ANDROID_16_minimums #ifdef VP_ANDROID_baseline_2021 -namespace VP_ANDROID_BASELINE_2021 { +namespace VP_ANDROID_BASELINE_2021 +{ static const VkStructureType featureStructTypes[] = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, @@ -1633,2685 +2431,9726 @@ static const VkStructureType formatStructTypes[] = { }; static const VkExtensionProperties instanceExtensions[] = { - VkExtensionProperties{ VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SURFACE_EXTENSION_NAME, 1 }, + VkExtensionProperties{VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SURFACE_EXTENSION_NAME, 1}, }; static const VkExtensionProperties deviceExtensions[] = { - VkExtensionProperties{ VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SWAPCHAIN_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, 1 }, + VkExtensionProperties{VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SWAPCHAIN_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, 1}, }; static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.depthBiasClamp = VK_TRUE; - s->features.fragmentStoresAndAtomics = VK_TRUE; - s->features.fullDrawIndexUint32 = VK_TRUE; - s->features.imageCubeArray = VK_TRUE; - s->features.independentBlend = VK_TRUE; - s->features.robustBufferAccess = VK_TRUE; - s->features.sampleRateShading = VK_TRUE; - s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; - s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; - s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; - s->features.textureCompressionASTC_LDR = VK_TRUE; - s->features.textureCompressionETC2 = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.depthBiasClamp == VK_TRUE); - ret = ret && (s->features.fragmentStoresAndAtomics == VK_TRUE); - ret = ret && (s->features.fullDrawIndexUint32 == VK_TRUE); - ret = ret && (s->features.imageCubeArray == VK_TRUE); - ret = ret && (s->features.independentBlend == VK_TRUE); - ret = ret && (s->features.robustBufferAccess == VK_TRUE); - ret = ret && (s->features.sampleRateShading == VK_TRUE); - ret = ret && (s->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.textureCompressionASTC_LDR == VK_TRUE); - ret = ret && (s->features.textureCompressionETC2 == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.depthBiasClamp = VK_TRUE; + s->features.fragmentStoresAndAtomics = VK_TRUE; + s->features.fullDrawIndexUint32 = VK_TRUE; + s->features.imageCubeArray = VK_TRUE; + s->features.independentBlend = VK_TRUE; + s->features.robustBufferAccess = VK_TRUE; + s->features.sampleRateShading = VK_TRUE; + s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; + s->features.textureCompressionASTC_LDR = VK_TRUE; + s->features.textureCompressionETC2 = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthBiasClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fragmentStoresAndAtomics == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fullDrawIndexUint32 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.imageCubeArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.independentBlend == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.sampleRateShading == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderSampledImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionASTC_LDR == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionASTC_LDR == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.textureCompressionASTC_LDR == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionETC2 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionETC2 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.textureCompressionETC2 == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; + [](VkBaseOutStructure *p) { + (void) p; }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } -}; + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - p->pNext = static_cast(static_cast(nullptr)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + p->pNext = static_cast(static_cast(nullptr)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - p->pNext = static_cast(static_cast(nullptr)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + p->pNext = static_cast(static_cast(nullptr)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkFormatProperties3KHR formatProperties3KHR{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr }; - p->pNext = static_cast(static_cast(&formatProperties3KHR)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkFormatProperties3KHR formatProperties3KHR{VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr}; + p->pNext = static_cast(static_cast(&formatProperties3KHR)); + pfnCb(p, pUser); }, }; -namespace baseline { +namespace blocks +{ +namespace baseline +{ + static const VkExtensionProperties instanceExtensions[] = { - VkExtensionProperties{ VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SURFACE_EXTENSION_NAME, 1 }, + VkExtensionProperties{VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SURFACE_EXTENSION_NAME, 1}, }; static const VkExtensionProperties deviceExtensions[] = { - VkExtensionProperties{ VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SWAPCHAIN_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, 1 }, + VkExtensionProperties{VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SWAPCHAIN_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, 1}, }; static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.depthBiasClamp = VK_TRUE; - s->features.fragmentStoresAndAtomics = VK_TRUE; - s->features.fullDrawIndexUint32 = VK_TRUE; - s->features.imageCubeArray = VK_TRUE; - s->features.independentBlend = VK_TRUE; - s->features.robustBufferAccess = VK_TRUE; - s->features.sampleRateShading = VK_TRUE; - s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; - s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; - s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; - s->features.textureCompressionASTC_LDR = VK_TRUE; - s->features.textureCompressionETC2 = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.depthBiasClamp == VK_TRUE); - ret = ret && (s->features.fragmentStoresAndAtomics == VK_TRUE); - ret = ret && (s->features.fullDrawIndexUint32 == VK_TRUE); - ret = ret && (s->features.imageCubeArray == VK_TRUE); - ret = ret && (s->features.independentBlend == VK_TRUE); - ret = ret && (s->features.robustBufferAccess == VK_TRUE); - ret = ret && (s->features.sampleRateShading == VK_TRUE); - ret = ret && (s->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.textureCompressionASTC_LDR == VK_TRUE); - ret = ret && (s->features.textureCompressionETC2 == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.depthBiasClamp = VK_TRUE; + s->features.fragmentStoresAndAtomics = VK_TRUE; + s->features.fullDrawIndexUint32 = VK_TRUE; + s->features.imageCubeArray = VK_TRUE; + s->features.independentBlend = VK_TRUE; + s->features.robustBufferAccess = VK_TRUE; + s->features.sampleRateShading = VK_TRUE; + s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; + s->features.textureCompressionASTC_LDR = VK_TRUE; + s->features.textureCompressionETC2 = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthBiasClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fragmentStoresAndAtomics == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fullDrawIndexUint32 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.imageCubeArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.independentBlend == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.sampleRateShading == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderSampledImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionASTC_LDR == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionASTC_LDR == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.textureCompressionASTC_LDR == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionETC2 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionETC2 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.textureCompressionETC2 == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - s->properties.limits.discreteQueuePriorities = 2; - s->properties.limits.framebufferColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.framebufferDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.framebufferNoAttachmentsSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.framebufferStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.maxBoundDescriptorSets = 4; - s->properties.limits.maxColorAttachments = 4; - s->properties.limits.maxComputeSharedMemorySize = 16384; - s->properties.limits.maxComputeWorkGroupCount[0] = 65535; - s->properties.limits.maxComputeWorkGroupCount[1] = 65535; - s->properties.limits.maxComputeWorkGroupCount[2] = 65535; - s->properties.limits.maxComputeWorkGroupInvocations = 128; - s->properties.limits.maxComputeWorkGroupSize[0] = 128; - s->properties.limits.maxComputeWorkGroupSize[1] = 128; - s->properties.limits.maxComputeWorkGroupSize[2] = 64; - s->properties.limits.maxDescriptorSetInputAttachments = 4; - s->properties.limits.maxDescriptorSetSampledImages = 48; - s->properties.limits.maxDescriptorSetSamplers = 48; - s->properties.limits.maxDescriptorSetStorageBuffers = 24; - s->properties.limits.maxDescriptorSetStorageBuffersDynamic = 4; - s->properties.limits.maxDescriptorSetStorageImages = 12; - s->properties.limits.maxDescriptorSetUniformBuffers = 36; - s->properties.limits.maxDescriptorSetUniformBuffersDynamic = 8; - s->properties.limits.maxDrawIndexedIndexValue = 4294967295; - s->properties.limits.maxDrawIndirectCount = 1; - s->properties.limits.maxFragmentCombinedOutputResources = 8; - s->properties.limits.maxFragmentInputComponents = 64; - s->properties.limits.maxFragmentOutputAttachments = 4; - s->properties.limits.maxFramebufferHeight = 4096; - s->properties.limits.maxFramebufferLayers = 256; - s->properties.limits.maxFramebufferWidth = 4096; - s->properties.limits.maxImageArrayLayers = 256; - s->properties.limits.maxImageDimension1D = 4096; - s->properties.limits.maxImageDimension2D = 4096; - s->properties.limits.maxImageDimension3D = 512; - s->properties.limits.maxImageDimensionCube = 4096; - s->properties.limits.maxInterpolationOffset = 0.4375f; - s->properties.limits.maxMemoryAllocationCount = 4096; - s->properties.limits.maxPerStageDescriptorInputAttachments = 4; - s->properties.limits.maxPerStageDescriptorSampledImages = 16; - s->properties.limits.maxPerStageDescriptorSamplers = 16; - s->properties.limits.maxPerStageDescriptorStorageBuffers = 4; - s->properties.limits.maxPerStageDescriptorStorageImages = 4; - s->properties.limits.maxPerStageDescriptorUniformBuffers = 12; - s->properties.limits.maxPerStageResources = 44; - s->properties.limits.maxPushConstantsSize = 128; - s->properties.limits.maxSampleMaskWords = 1; - s->properties.limits.maxSamplerAllocationCount = 4000; - s->properties.limits.maxSamplerAnisotropy = 1.0f; - s->properties.limits.maxSamplerLodBias = 2.0f; - s->properties.limits.maxStorageBufferRange = 134217728; - s->properties.limits.maxTexelBufferElements = 65536; - s->properties.limits.maxTexelOffset = 7; - s->properties.limits.maxUniformBufferRange = 16384; - s->properties.limits.maxVertexInputAttributeOffset = 2047; - s->properties.limits.maxVertexInputAttributes = 16; - s->properties.limits.maxVertexInputBindingStride = 2048; - s->properties.limits.maxVertexInputBindings = 16; - s->properties.limits.maxVertexOutputComponents = 64; - s->properties.limits.maxViewportDimensions[0] = 4096; - s->properties.limits.maxViewportDimensions[1] = 4096; - s->properties.limits.maxViewports = 1; - s->properties.limits.minInterpolationOffset = -0.5f; - s->properties.limits.minStorageBufferOffsetAlignment = 256; - s->properties.limits.minTexelBufferOffsetAlignment = 256; - s->properties.limits.minTexelOffset = -8; - s->properties.limits.minUniformBufferOffsetAlignment = 256; - s->properties.limits.mipmapPrecisionBits = 4; - s->properties.limits.pointSizeGranularity = 1; - s->properties.limits.sampledImageColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sampledImageDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sampledImageIntegerSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); - s->properties.limits.sampledImageStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.standardSampleLocations = VK_TRUE; - s->properties.limits.storageImageSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); - s->properties.limits.subPixelInterpolationOffsetBits = 4; - s->properties.limits.subPixelPrecisionBits = 4; - s->properties.limits.subTexelPrecisionBits = 4; - s->properties.limits.viewportBoundsRange[0] = -8192; - s->properties.limits.viewportBoundsRange[1] = 8191; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->properties.limits.discreteQueuePriorities >= 2); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (s->properties.limits.maxBoundDescriptorSets >= 4); - ret = ret && (s->properties.limits.maxColorAttachments >= 4); - ret = ret && (s->properties.limits.maxComputeSharedMemorySize >= 16384); - ret = ret && (s->properties.limits.maxComputeWorkGroupCount[0] >= 65535); - ret = ret && (s->properties.limits.maxComputeWorkGroupCount[1] >= 65535); - ret = ret && (s->properties.limits.maxComputeWorkGroupCount[2] >= 65535); - ret = ret && (s->properties.limits.maxComputeWorkGroupInvocations >= 128); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[0] >= 128); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[1] >= 128); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[2] >= 64); - ret = ret && (s->properties.limits.maxDescriptorSetInputAttachments >= 4); - ret = ret && (s->properties.limits.maxDescriptorSetSampledImages >= 48); - ret = ret && (s->properties.limits.maxDescriptorSetSamplers >= 48); - ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffers >= 24); - ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4); - ret = ret && (s->properties.limits.maxDescriptorSetStorageImages >= 12); - ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffers >= 36); - ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8); - ret = ret && (s->properties.limits.maxDrawIndexedIndexValue >= 4294967295); - ret = ret && (s->properties.limits.maxDrawIndirectCount >= 1); - ret = ret && (s->properties.limits.maxFragmentCombinedOutputResources >= 8); - ret = ret && (s->properties.limits.maxFragmentInputComponents >= 64); - ret = ret && (s->properties.limits.maxFragmentOutputAttachments >= 4); - ret = ret && (s->properties.limits.maxFramebufferHeight >= 4096); - ret = ret && (s->properties.limits.maxFramebufferLayers >= 256); - ret = ret && (s->properties.limits.maxFramebufferWidth >= 4096); - ret = ret && (s->properties.limits.maxImageArrayLayers >= 256); - ret = ret && (s->properties.limits.maxImageDimension1D >= 4096); - ret = ret && (s->properties.limits.maxImageDimension2D >= 4096); - ret = ret && (s->properties.limits.maxImageDimension3D >= 512); - ret = ret && (s->properties.limits.maxImageDimensionCube >= 4096); - ret = ret && (s->properties.limits.maxInterpolationOffset >= 0.4375); - ret = ret && (s->properties.limits.maxMemoryAllocationCount >= 4096); - ret = ret && (s->properties.limits.maxPerStageDescriptorInputAttachments >= 4); - ret = ret && (s->properties.limits.maxPerStageDescriptorSampledImages >= 16); - ret = ret && (s->properties.limits.maxPerStageDescriptorSamplers >= 16); - ret = ret && (s->properties.limits.maxPerStageDescriptorStorageBuffers >= 4); - ret = ret && (s->properties.limits.maxPerStageDescriptorStorageImages >= 4); - ret = ret && (s->properties.limits.maxPerStageDescriptorUniformBuffers >= 12); - ret = ret && (s->properties.limits.maxPerStageResources >= 44); - ret = ret && (s->properties.limits.maxPushConstantsSize >= 128); - ret = ret && (s->properties.limits.maxSampleMaskWords >= 1); - ret = ret && (s->properties.limits.maxSamplerAllocationCount >= 4000); - ret = ret && (s->properties.limits.maxSamplerAnisotropy >= 1.0); - ret = ret && (s->properties.limits.maxSamplerLodBias >= 2.0); - ret = ret && (s->properties.limits.maxStorageBufferRange >= 134217728); - ret = ret && (s->properties.limits.maxTexelBufferElements >= 65536); - ret = ret && (s->properties.limits.maxTexelOffset >= 7); - ret = ret && (s->properties.limits.maxUniformBufferRange >= 16384); - ret = ret && (s->properties.limits.maxVertexInputAttributeOffset >= 2047); - ret = ret && (s->properties.limits.maxVertexInputAttributes >= 16); - ret = ret && (s->properties.limits.maxVertexInputBindingStride >= 2048); - ret = ret && (s->properties.limits.maxVertexInputBindings >= 16); - ret = ret && (s->properties.limits.maxVertexOutputComponents >= 64); - ret = ret && (s->properties.limits.maxViewportDimensions[0] >= 4096); - ret = ret && (s->properties.limits.maxViewportDimensions[1] >= 4096); - ret = ret && (s->properties.limits.maxViewports >= 1); - ret = ret && (s->properties.limits.minInterpolationOffset <= -0.5); - ret = ret && (s->properties.limits.minStorageBufferOffsetAlignment <= 256); - ret = ret && ((s->properties.limits.minStorageBufferOffsetAlignment & (s->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0); - ret = ret && (s->properties.limits.minTexelBufferOffsetAlignment <= 256); - ret = ret && ((s->properties.limits.minTexelBufferOffsetAlignment & (s->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0); - ret = ret && (s->properties.limits.minTexelOffset <= -8); - ret = ret && (s->properties.limits.minUniformBufferOffsetAlignment <= 256); - ret = ret && ((s->properties.limits.minUniformBufferOffsetAlignment & (s->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0); - ret = ret && (s->properties.limits.mipmapPrecisionBits >= 4); - ret = ret && (s->properties.limits.pointSizeGranularity <= 1); - ret = ret && (isMultiple(1, s->properties.limits.pointSizeGranularity)); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (s->properties.limits.standardSampleLocations == VK_TRUE); - ret = ret && (vpCheckFlags(s->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); - ret = ret && (s->properties.limits.subPixelInterpolationOffsetBits >= 4); - ret = ret && (s->properties.limits.subPixelPrecisionBits >= 4); - ret = ret && (s->properties.limits.subTexelPrecisionBits >= 4); - ret = ret && (s->properties.limits.viewportBoundsRange[0] <= -8192); - ret = ret && (s->properties.limits.viewportBoundsRange[1] >= 8191); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *s = static_cast(static_cast(p)); + s->properties.limits.discreteQueuePriorities = 2; + s->properties.limits.framebufferColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferNoAttachmentsSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.maxBoundDescriptorSets = 4; + s->properties.limits.maxColorAttachments = 4; + s->properties.limits.maxComputeSharedMemorySize = 16384; + s->properties.limits.maxComputeWorkGroupCount[0] = 65535; + s->properties.limits.maxComputeWorkGroupCount[1] = 65535; + s->properties.limits.maxComputeWorkGroupCount[2] = 65535; + s->properties.limits.maxComputeWorkGroupInvocations = 128; + s->properties.limits.maxComputeWorkGroupSize[0] = 128; + s->properties.limits.maxComputeWorkGroupSize[1] = 128; + s->properties.limits.maxComputeWorkGroupSize[2] = 64; + s->properties.limits.maxDescriptorSetInputAttachments = 4; + s->properties.limits.maxDescriptorSetSampledImages = 48; + s->properties.limits.maxDescriptorSetSamplers = 48; + s->properties.limits.maxDescriptorSetStorageBuffers = 24; + s->properties.limits.maxDescriptorSetStorageBuffersDynamic = 4; + s->properties.limits.maxDescriptorSetStorageImages = 12; + s->properties.limits.maxDescriptorSetUniformBuffers = 36; + s->properties.limits.maxDescriptorSetUniformBuffersDynamic = 8; + s->properties.limits.maxDrawIndexedIndexValue = 4294967295; + s->properties.limits.maxDrawIndirectCount = 1; + s->properties.limits.maxFragmentCombinedOutputResources = 8; + s->properties.limits.maxFragmentInputComponents = 64; + s->properties.limits.maxFragmentOutputAttachments = 4; + s->properties.limits.maxFramebufferHeight = 4096; + s->properties.limits.maxFramebufferLayers = 256; + s->properties.limits.maxFramebufferWidth = 4096; + s->properties.limits.maxImageArrayLayers = 256; + s->properties.limits.maxImageDimension1D = 4096; + s->properties.limits.maxImageDimension2D = 4096; + s->properties.limits.maxImageDimension3D = 512; + s->properties.limits.maxImageDimensionCube = 4096; + s->properties.limits.maxInterpolationOffset = 0.4375f; + s->properties.limits.maxMemoryAllocationCount = 4096; + s->properties.limits.maxPerStageDescriptorInputAttachments = 4; + s->properties.limits.maxPerStageDescriptorSampledImages = 16; + s->properties.limits.maxPerStageDescriptorSamplers = 16; + s->properties.limits.maxPerStageDescriptorStorageBuffers = 4; + s->properties.limits.maxPerStageDescriptorStorageImages = 4; + s->properties.limits.maxPerStageDescriptorUniformBuffers = 12; + s->properties.limits.maxPerStageResources = 44; + s->properties.limits.maxPushConstantsSize = 128; + s->properties.limits.maxSampleMaskWords = 1; + s->properties.limits.maxSamplerAllocationCount = 4000; + s->properties.limits.maxSamplerAnisotropy = 1.0f; + s->properties.limits.maxSamplerLodBias = 2.0f; + s->properties.limits.maxStorageBufferRange = 134217728; + s->properties.limits.maxTexelBufferElements = 65536; + s->properties.limits.maxTexelOffset = 7; + s->properties.limits.maxUniformBufferRange = 16384; + s->properties.limits.maxVertexInputAttributeOffset = 2047; + s->properties.limits.maxVertexInputAttributes = 16; + s->properties.limits.maxVertexInputBindingStride = 2048; + s->properties.limits.maxVertexInputBindings = 16; + s->properties.limits.maxVertexOutputComponents = 64; + s->properties.limits.maxViewportDimensions[0] = 4096; + s->properties.limits.maxViewportDimensions[1] = 4096; + s->properties.limits.maxViewports = 1; + s->properties.limits.minInterpolationOffset = -0.5f; + s->properties.limits.minStorageBufferOffsetAlignment = 256; + s->properties.limits.minTexelBufferOffsetAlignment = 256; + s->properties.limits.minTexelOffset = -8; + s->properties.limits.minUniformBufferOffsetAlignment = 256; + s->properties.limits.mipmapPrecisionBits = 4; + s->properties.limits.pointSizeGranularity = 1; + s->properties.limits.sampledImageColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageIntegerSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); + s->properties.limits.sampledImageStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.standardSampleLocations = VK_TRUE; + s->properties.limits.storageImageSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); + s->properties.limits.subPixelInterpolationOffsetBits = 4; + s->properties.limits.subPixelPrecisionBits = 4; + s->properties.limits.subTexelPrecisionBits = 4; + s->properties.limits.viewportBoundsRange[0] = -8192; + s->properties.limits.viewportBoundsRange[1] = 8191; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *prettify_VkPhysicalDeviceProperties2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.discreteQueuePriorities >= 2); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.discreteQueuePriorities >= 2), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.discreteQueuePriorities >= 2"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferDepthSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferNoAttachmentsSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferStencilSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxBoundDescriptorSets >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxColorAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeSharedMemorySize >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeSharedMemorySize >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeSharedMemorySize >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[0] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[0] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[0] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[1] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[1] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[1] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[2] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[2] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[2] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupInvocations >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[0] >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[1] >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[2] >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetInputAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetInputAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetInputAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 48); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 48), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSampledImages >= 48"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 48); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 48), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSamplers >= 48"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 24); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 24), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffers >= 24"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 12); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 12), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageImages >= 12"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 36); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 36), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffers >= 36"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndexedIndexValue >= 4294967295); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndexedIndexValue >= 4294967295), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDrawIndexedIndexValue >= 4294967295"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndirectCount >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndirectCount >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDrawIndirectCount >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentCombinedOutputResources >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentInputComponents >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentInputComponents >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentInputComponents >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentOutputAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentOutputAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentOutputAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferHeight >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferHeight >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferHeight >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferLayers >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferLayers >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferLayers >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferWidth >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferWidth >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferWidth >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageArrayLayers >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension1D >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension2D >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension3D >= 512); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension3D >= 512), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension3D >= 512"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimensionCube >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxInterpolationOffset >= 0.4375); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxInterpolationOffset >= 0.4375), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxInterpolationOffset >= 0.4375"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxMemoryAllocationCount >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxMemoryAllocationCount >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxMemoryAllocationCount >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorInputAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorInputAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorInputAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSampledImages >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSamplers >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageBuffers >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageImages >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 12); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 12), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorUniformBuffers >= 12"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 44); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 44), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageResources >= 44"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPushConstantsSize >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPushConstantsSize >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPushConstantsSize >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSampleMaskWords >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSampleMaskWords >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSampleMaskWords >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAllocationCount >= 4000); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAllocationCount >= 4000), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerAllocationCount >= 4000"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAnisotropy >= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAnisotropy >= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerAnisotropy >= 1.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 2.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 2.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerLodBias >= 2.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxStorageBufferRange >= 134217728); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxStorageBufferRange >= 134217728), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxStorageBufferRange >= 134217728"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelBufferElements >= 65536); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelBufferElements >= 65536), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelBufferElements >= 65536"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelOffset >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelOffset >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelOffset >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxUniformBufferRange >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributeOffset >= 2047); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributeOffset >= 2047), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputAttributeOffset >= 2047"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributes >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributes >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputAttributes >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindingStride >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindingStride >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputBindingStride >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindings >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindings >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputBindings >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexOutputComponents >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[0] >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[0] >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewportDimensions[0] >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[1] >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[1] >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewportDimensions[1] >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewports >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewports >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewports >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minInterpolationOffset <= -0.5); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minInterpolationOffset <= -0.5), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minInterpolationOffset <= -0.5"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minStorageBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelOffset <= -8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelOffset <= -8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelOffset <= -8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minUniformBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.mipmapPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeGranularity <= 1"); + ret = ret && (isMultiple(1, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)); + VP_DEBUG_COND_MSG(!(isMultiple(1, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)), "Unsupported properties condition: isMultiple(1, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageDepthSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageIntegerSampleCounts contains (VK_SAMPLE_COUNT_1_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageStencilSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.standardSampleLocations >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.standardSampleLocations >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.standardSampleLocations >= VK_TRUE"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.storageImageSampleCounts contains (VK_SAMPLE_COUNT_1_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelInterpolationOffsetBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelInterpolationOffsetBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subPixelInterpolationOffsetBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subPixelPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subTexelPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[0] <= -8192); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[0] <= -8192), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportBoundsRange[0] <= -8192"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[1] >= 8191); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[1] >= 8191), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportBoundsRange[1] >= 8191"); + } + break; + default: + break; + } + return ret; + }}; static const VpFormatDesc formatDesc[] = { - { - VK_FORMAT_A1R5G5B5_UNORM_PACK16, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_A2B10G10R10_UINT_PACK32, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_A2B10G10R10_UNORM_PACK32, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_A8B8G8R8_SINT_PACK32, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_A8B8G8R8_SNORM_PACK32, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_A8B8G8R8_SRGB_PACK32, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_A8B8G8R8_UINT_PACK32, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_A8B8G8R8_UNORM_PACK32, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_10x10_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_10x10_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + {VK_FORMAT_A1R5G5B5_UNORM_PACK16, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A1R5G5B5_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A1R5G5B5_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A2B10G10R10_UINT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A2B10G10R10_UNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_SINT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_SNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_SRGB_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SRGB_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SRGB_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_UINT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_UNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_10x10_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x10_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x10_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_10x10_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x10_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x10_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_10x5_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x5_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x5_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_10x5_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x5_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x5_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_10x6_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x6_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x6_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_10x6_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x6_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x6_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_10x8_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x8_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x8_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_10x8_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x8_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x8_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_12x10_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_12x10_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_12x10_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_12x10_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_12x10_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_12x10_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_12x12_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_12x12_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_12x12_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_12x12_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_12x12_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_12x12_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_4x4_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_4x4_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_4x4_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_4x4_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_4x4_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_4x4_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_5x4_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_5x4_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_5x4_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_5x4_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_5x4_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_5x4_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_5x5_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_5x5_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_5x5_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_5x5_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_5x5_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_5x5_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_6x5_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_6x5_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_6x5_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_6x5_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_6x5_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_6x5_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_6x6_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_6x6_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_6x6_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_6x6_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_6x6_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_6x6_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_8x5_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x5_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x5_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_8x5_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x5_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x5_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_8x6_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x6_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x6_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_8x6_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x6_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x6_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_8x8_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x8_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x8_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_8x8_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x8_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x8_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_B10G11R11_UFLOAT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_B4G4R4A4_UNORM_PACK16, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B4G4R4A4_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B4G4R4A4_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_B8G8R8A8_SRGB, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_SRGB: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_SRGB: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_B8G8R8A8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_D16_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_D16_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_D32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_D32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_EAC_R11G11_SNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_EAC_R11G11_SNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_EAC_R11G11_SNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_EAC_R11G11_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_EAC_R11G11_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_EAC_R11G11_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_EAC_R11_SNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_EAC_R11_SNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_EAC_R11_SNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_EAC_R11_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_EAC_R11_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_EAC_R11_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32A32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32A32_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32A32_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R5G6B5_UNORM_PACK16, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R5G6B5_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R5G6B5_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_SRGB, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SRGB: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SRGB: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, +}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + p->pNext = static_cast(static_cast(nullptr)); + pfnCb(p, pUser); }, - { - VK_FORMAT_ASTC_10x5_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + p->pNext = static_cast(static_cast(nullptr)); + pfnCb(p, pUser); }, - { - VK_FORMAT_ASTC_10x5_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); }, - { - VK_FORMAT_ASTC_10x6_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkFormatProperties3KHR formatProperties3KHR{VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr}; + p->pNext = static_cast(static_cast(&formatProperties3KHR)); + pfnCb(p, pUser); }, - { - VK_FORMAT_ASTC_10x6_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } +}; +} // namespace baseline +} // namespace blocks +} // namespace VP_ANDROID_BASELINE_2021 +#endif // VP_ANDROID_baseline_2021 + +#ifdef VP_ANDROID_baseline_2022 +namespace VP_ANDROID_BASELINE_2022 +{ + +static const VkStructureType featureStructTypes[] = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, +}; + +static const VkStructureType propertyStructTypes[] = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, +}; + +static const VkStructureType formatStructTypes[] = { + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, +}; + +static const VkExtensionProperties instanceExtensions[] = { + VkExtensionProperties{VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SURFACE_EXTENSION_NAME, 1}, +}; + +static const VkExtensionProperties deviceExtensions[] = { + VkExtensionProperties{VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SWAPCHAIN_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, 1}, +}; + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.depthBiasClamp = VK_TRUE; + s->features.fragmentStoresAndAtomics = VK_TRUE; + s->features.fullDrawIndexUint32 = VK_TRUE; + s->features.imageCubeArray = VK_TRUE; + s->features.independentBlend = VK_TRUE; + s->features.largePoints = VK_TRUE; + s->features.robustBufferAccess = VK_TRUE; + s->features.sampleRateShading = VK_TRUE; + s->features.shaderInt16 = VK_TRUE; + s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageBufferArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; + s->features.textureCompressionASTC_LDR = VK_TRUE; + s->features.textureCompressionETC2 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + { + VkPhysicalDeviceMultiviewFeatures *s = static_cast(static_cast(p)); + s->multiview = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + { + VkPhysicalDeviceSamplerYcbcrConversionFeatures *s = static_cast(static_cast(p)); + s->samplerYcbcrConversion = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + { + VkPhysicalDeviceShaderDrawParametersFeatures *s = static_cast(static_cast(p)); + s->shaderDrawParameters = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + { + VkPhysicalDeviceVariablePointersFeatures *s = static_cast(static_cast(p)); + s->variablePointers = VK_TRUE; + s->variablePointersStorageBuffer = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthBiasClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fragmentStoresAndAtomics == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fullDrawIndexUint32 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.imageCubeArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.independentBlend == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.largePoints == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.largePoints == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.largePoints == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.sampleRateShading == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderInt16 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderInt16 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderInt16 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderSampledImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionASTC_LDR == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionASTC_LDR == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.textureCompressionASTC_LDR == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionETC2 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionETC2 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.textureCompressionETC2 == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + { + VkPhysicalDeviceMultiviewFeatures *prettify_VkPhysicalDeviceMultiviewFeatures = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceMultiviewFeatures->multiview == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceMultiviewFeatures->multiview == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceMultiviewFeatures::multiview == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + { + VkPhysicalDeviceSamplerYcbcrConversionFeatures *prettify_VkPhysicalDeviceSamplerYcbcrConversionFeatures = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceSamplerYcbcrConversionFeatures->samplerYcbcrConversion == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceSamplerYcbcrConversionFeatures->samplerYcbcrConversion == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceSamplerYcbcrConversionFeatures::samplerYcbcrConversion == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + { + VkPhysicalDeviceShaderDrawParametersFeatures *prettify_VkPhysicalDeviceShaderDrawParametersFeatures = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceShaderDrawParametersFeatures->shaderDrawParameters == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceShaderDrawParametersFeatures->shaderDrawParameters == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceShaderDrawParametersFeatures::shaderDrawParameters == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + { + VkPhysicalDeviceVariablePointersFeatures *prettify_VkPhysicalDeviceVariablePointersFeatures = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVariablePointersFeatures->variablePointers == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVariablePointersFeatures->variablePointers == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVariablePointersFeatures::variablePointers == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVariablePointersFeatures->variablePointersStorageBuffer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVariablePointersFeatures->variablePointersStorageBuffer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVariablePointersFeatures::variablePointersStorageBuffer == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; }, - { - VK_FORMAT_ASTC_10x8_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceMultiviewFeatures physicalDeviceMultiviewFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, nullptr}; + VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceMultiviewFeatures}; + VkPhysicalDeviceShaderDrawParametersFeatures physicalDeviceShaderDrawParametersFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures}; + VkPhysicalDeviceVariablePointersFeatures physicalDeviceVariablePointersFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, &physicalDeviceShaderDrawParametersFeatures}; + p->pNext = static_cast(static_cast(&physicalDeviceVariablePointersFeatures)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceMultiviewProperties physicalDeviceMultiviewProperties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, nullptr}; + p->pNext = static_cast(static_cast(&physicalDeviceMultiviewProperties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkFormatProperties3KHR formatProperties3KHR{VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr}; + p->pNext = static_cast(static_cast(&formatProperties3KHR)); + pfnCb(p, pUser); }, - { - VK_FORMAT_ASTC_10x8_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } +}; + +namespace blocks +{ +namespace baseline +{ + +static const VkExtensionProperties instanceExtensions[] = { + VkExtensionProperties{VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SURFACE_EXTENSION_NAME, 1}, +}; + +static const VkExtensionProperties deviceExtensions[] = { + VkExtensionProperties{VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SWAPCHAIN_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, 1}, +}; + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.depthBiasClamp = VK_TRUE; + s->features.fragmentStoresAndAtomics = VK_TRUE; + s->features.fullDrawIndexUint32 = VK_TRUE; + s->features.imageCubeArray = VK_TRUE; + s->features.independentBlend = VK_TRUE; + s->features.largePoints = VK_TRUE; + s->features.robustBufferAccess = VK_TRUE; + s->features.sampleRateShading = VK_TRUE; + s->features.shaderInt16 = VK_TRUE; + s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageBufferArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; + s->features.textureCompressionASTC_LDR = VK_TRUE; + s->features.textureCompressionETC2 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + { + VkPhysicalDeviceMultiviewFeatures *s = static_cast(static_cast(p)); + s->multiview = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + { + VkPhysicalDeviceSamplerYcbcrConversionFeatures *s = static_cast(static_cast(p)); + s->samplerYcbcrConversion = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + { + VkPhysicalDeviceShaderDrawParametersFeatures *s = static_cast(static_cast(p)); + s->shaderDrawParameters = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + { + VkPhysicalDeviceVariablePointersFeatures *s = static_cast(static_cast(p)); + s->variablePointers = VK_TRUE; + s->variablePointersStorageBuffer = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthBiasClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fragmentStoresAndAtomics == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fullDrawIndexUint32 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.imageCubeArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.independentBlend == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.largePoints == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.largePoints == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.largePoints == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.sampleRateShading == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderInt16 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderInt16 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderInt16 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderSampledImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionASTC_LDR == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionASTC_LDR == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.textureCompressionASTC_LDR == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionETC2 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionETC2 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.textureCompressionETC2 == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + { + VkPhysicalDeviceMultiviewFeatures *prettify_VkPhysicalDeviceMultiviewFeatures = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceMultiviewFeatures->multiview == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceMultiviewFeatures->multiview == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceMultiviewFeatures::multiview == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + { + VkPhysicalDeviceSamplerYcbcrConversionFeatures *prettify_VkPhysicalDeviceSamplerYcbcrConversionFeatures = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceSamplerYcbcrConversionFeatures->samplerYcbcrConversion == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceSamplerYcbcrConversionFeatures->samplerYcbcrConversion == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceSamplerYcbcrConversionFeatures::samplerYcbcrConversion == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + { + VkPhysicalDeviceShaderDrawParametersFeatures *prettify_VkPhysicalDeviceShaderDrawParametersFeatures = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceShaderDrawParametersFeatures->shaderDrawParameters == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceShaderDrawParametersFeatures->shaderDrawParameters == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceShaderDrawParametersFeatures::shaderDrawParameters == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + { + VkPhysicalDeviceVariablePointersFeatures *prettify_VkPhysicalDeviceVariablePointersFeatures = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVariablePointersFeatures->variablePointers == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVariablePointersFeatures->variablePointers == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVariablePointersFeatures::variablePointers == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVariablePointersFeatures->variablePointersStorageBuffer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVariablePointersFeatures->variablePointersStorageBuffer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVariablePointersFeatures::variablePointersStorageBuffer == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *s = static_cast(static_cast(p)); + s->properties.limits.discreteQueuePriorities = 2; + s->properties.limits.framebufferColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferNoAttachmentsSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.maxBoundDescriptorSets = 4; + s->properties.limits.maxColorAttachments = 4; + s->properties.limits.maxComputeSharedMemorySize = 16384; + s->properties.limits.maxComputeWorkGroupCount[0] = 65535; + s->properties.limits.maxComputeWorkGroupCount[1] = 65535; + s->properties.limits.maxComputeWorkGroupCount[2] = 65535; + s->properties.limits.maxComputeWorkGroupInvocations = 128; + s->properties.limits.maxComputeWorkGroupSize[0] = 128; + s->properties.limits.maxComputeWorkGroupSize[1] = 128; + s->properties.limits.maxComputeWorkGroupSize[2] = 64; + s->properties.limits.maxDescriptorSetInputAttachments = 4; + s->properties.limits.maxDescriptorSetSampledImages = 48; + s->properties.limits.maxDescriptorSetSamplers = 48; + s->properties.limits.maxDescriptorSetStorageBuffers = 24; + s->properties.limits.maxDescriptorSetStorageBuffersDynamic = 4; + s->properties.limits.maxDescriptorSetStorageImages = 12; + s->properties.limits.maxDescriptorSetUniformBuffers = 36; + s->properties.limits.maxDescriptorSetUniformBuffersDynamic = 8; + s->properties.limits.maxDrawIndexedIndexValue = 4294967295; + s->properties.limits.maxDrawIndirectCount = 1; + s->properties.limits.maxFragmentCombinedOutputResources = 8; + s->properties.limits.maxFragmentInputComponents = 64; + s->properties.limits.maxFragmentOutputAttachments = 4; + s->properties.limits.maxFramebufferHeight = 4096; + s->properties.limits.maxFramebufferLayers = 256; + s->properties.limits.maxFramebufferWidth = 4096; + s->properties.limits.maxImageArrayLayers = 256; + s->properties.limits.maxImageDimension1D = 4096; + s->properties.limits.maxImageDimension2D = 4096; + s->properties.limits.maxImageDimension3D = 512; + s->properties.limits.maxImageDimensionCube = 4096; + s->properties.limits.maxInterpolationOffset = 0.4375f; + s->properties.limits.maxMemoryAllocationCount = 4096; + s->properties.limits.maxPerStageDescriptorInputAttachments = 4; + s->properties.limits.maxPerStageDescriptorSampledImages = 16; + s->properties.limits.maxPerStageDescriptorSamplers = 16; + s->properties.limits.maxPerStageDescriptorStorageBuffers = 4; + s->properties.limits.maxPerStageDescriptorStorageImages = 4; + s->properties.limits.maxPerStageDescriptorUniformBuffers = 12; + s->properties.limits.maxPerStageResources = 44; + s->properties.limits.maxPushConstantsSize = 128; + s->properties.limits.maxSampleMaskWords = 1; + s->properties.limits.maxSamplerAllocationCount = 4000; + s->properties.limits.maxSamplerAnisotropy = 1.0f; + s->properties.limits.maxSamplerLodBias = 2.0f; + s->properties.limits.maxStorageBufferRange = 134217728; + s->properties.limits.maxTexelBufferElements = 65536; + s->properties.limits.maxTexelOffset = 7; + s->properties.limits.maxUniformBufferRange = 16384; + s->properties.limits.maxVertexInputAttributeOffset = 2047; + s->properties.limits.maxVertexInputAttributes = 16; + s->properties.limits.maxVertexInputBindingStride = 2048; + s->properties.limits.maxVertexInputBindings = 16; + s->properties.limits.maxVertexOutputComponents = 64; + s->properties.limits.maxViewportDimensions[0] = 4096; + s->properties.limits.maxViewportDimensions[1] = 4096; + s->properties.limits.maxViewports = 1; + s->properties.limits.minInterpolationOffset = -0.5f; + s->properties.limits.minStorageBufferOffsetAlignment = 256; + s->properties.limits.minTexelBufferOffsetAlignment = 256; + s->properties.limits.minTexelOffset = -8; + s->properties.limits.minUniformBufferOffsetAlignment = 256; + s->properties.limits.mipmapPrecisionBits = 4; + s->properties.limits.pointSizeGranularity = 1; + s->properties.limits.pointSizeRange[0] = 1.0f; + s->properties.limits.pointSizeRange[1] = 511; + s->properties.limits.sampledImageColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageIntegerSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); + s->properties.limits.sampledImageStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.standardSampleLocations = VK_TRUE; + s->properties.limits.storageImageSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); + s->properties.limits.subPixelInterpolationOffsetBits = 4; + s->properties.limits.subPixelPrecisionBits = 4; + s->properties.limits.subTexelPrecisionBits = 4; + s->properties.limits.viewportBoundsRange[0] = -8192; + s->properties.limits.viewportBoundsRange[1] = 8191; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: + { + VkPhysicalDeviceMultiviewProperties *s = static_cast(static_cast(p)); + s->maxMultiviewInstanceIndex = 134217727; + s->maxMultiviewViewCount = 6; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *prettify_VkPhysicalDeviceProperties2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.discreteQueuePriorities >= 2); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.discreteQueuePriorities >= 2), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.discreteQueuePriorities >= 2"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferDepthSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferNoAttachmentsSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferStencilSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxBoundDescriptorSets >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxColorAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeSharedMemorySize >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeSharedMemorySize >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeSharedMemorySize >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[0] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[0] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[0] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[1] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[1] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[1] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[2] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[2] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[2] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupInvocations >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[0] >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[1] >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[2] >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetInputAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetInputAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetInputAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 48); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 48), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSampledImages >= 48"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 48); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 48), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSamplers >= 48"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 24); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 24), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffers >= 24"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 12); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 12), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageImages >= 12"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 36); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 36), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffers >= 36"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndexedIndexValue >= 4294967295); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndexedIndexValue >= 4294967295), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDrawIndexedIndexValue >= 4294967295"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndirectCount >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndirectCount >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDrawIndirectCount >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentCombinedOutputResources >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentInputComponents >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentInputComponents >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentInputComponents >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentOutputAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentOutputAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentOutputAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferHeight >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferHeight >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferHeight >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferLayers >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferLayers >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferLayers >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferWidth >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferWidth >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferWidth >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageArrayLayers >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension1D >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension2D >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension3D >= 512); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension3D >= 512), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension3D >= 512"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimensionCube >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxInterpolationOffset >= 0.4375); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxInterpolationOffset >= 0.4375), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxInterpolationOffset >= 0.4375"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxMemoryAllocationCount >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxMemoryAllocationCount >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxMemoryAllocationCount >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorInputAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorInputAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorInputAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSampledImages >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSamplers >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageBuffers >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageImages >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 12); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 12), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorUniformBuffers >= 12"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 44); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 44), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageResources >= 44"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPushConstantsSize >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPushConstantsSize >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPushConstantsSize >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSampleMaskWords >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSampleMaskWords >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSampleMaskWords >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAllocationCount >= 4000); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAllocationCount >= 4000), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerAllocationCount >= 4000"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAnisotropy >= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAnisotropy >= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerAnisotropy >= 1.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 2.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 2.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerLodBias >= 2.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxStorageBufferRange >= 134217728); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxStorageBufferRange >= 134217728), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxStorageBufferRange >= 134217728"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelBufferElements >= 65536); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelBufferElements >= 65536), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelBufferElements >= 65536"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelOffset >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelOffset >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelOffset >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxUniformBufferRange >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributeOffset >= 2047); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributeOffset >= 2047), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputAttributeOffset >= 2047"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributes >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributes >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputAttributes >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindingStride >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindingStride >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputBindingStride >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindings >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindings >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputBindings >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexOutputComponents >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[0] >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[0] >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewportDimensions[0] >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[1] >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[1] >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewportDimensions[1] >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewports >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewports >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewports >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minInterpolationOffset <= -0.5); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minInterpolationOffset <= -0.5), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minInterpolationOffset <= -0.5"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minStorageBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelOffset <= -8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelOffset <= -8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelOffset <= -8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minUniformBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.mipmapPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeGranularity <= 1"); + ret = ret && (isMultiple(1, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)); + VP_DEBUG_COND_MSG(!(isMultiple(1, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)), "Unsupported properties condition: isMultiple(1, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[0] <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[0] <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeRange[0] <= 1.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[1] >= 511); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[1] >= 511), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeRange[1] >= 511"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageDepthSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageIntegerSampleCounts contains (VK_SAMPLE_COUNT_1_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageStencilSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.standardSampleLocations >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.standardSampleLocations >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.standardSampleLocations >= VK_TRUE"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.storageImageSampleCounts contains (VK_SAMPLE_COUNT_1_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelInterpolationOffsetBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelInterpolationOffsetBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subPixelInterpolationOffsetBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subPixelPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subTexelPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[0] <= -8192); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[0] <= -8192), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportBoundsRange[0] <= -8192"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[1] >= 8191); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[1] >= 8191), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportBoundsRange[1] >= 8191"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: + { + VkPhysicalDeviceMultiviewProperties *prettify_VkPhysicalDeviceMultiviewProperties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceMultiviewProperties->maxMultiviewInstanceIndex >= 134217727); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceMultiviewProperties->maxMultiviewInstanceIndex >= 134217727), "Unsupported properties condition: VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex >= 134217727"); + ret = ret && (prettify_VkPhysicalDeviceMultiviewProperties->maxMultiviewViewCount >= 6); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceMultiviewProperties->maxMultiviewViewCount >= 6), "Unsupported properties condition: VkPhysicalDeviceMultiviewProperties::maxMultiviewViewCount >= 6"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpFormatDesc formatDesc[] = { + {VK_FORMAT_A1R5G5B5_UNORM_PACK16, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A1R5G5B5_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A1R5G5B5_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A2B10G10R10_UINT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A2B10G10R10_UNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_SINT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_SNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_SRGB_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SRGB_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SRGB_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_UINT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_UNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_10x10_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x10_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x10_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_10x10_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x10_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x10_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_10x5_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x5_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x5_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_10x5_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x5_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x5_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_10x6_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x6_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x6_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_10x6_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x6_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x6_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_10x8_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x8_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x8_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_10x8_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x8_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_10x8_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_12x10_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_12x10_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_12x10_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_12x10_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_12x10_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_12x10_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_12x12_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_12x12_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_12x12_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_12x12_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_12x12_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_12x12_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_4x4_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_4x4_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_4x4_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_4x4_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_4x4_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_4x4_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_5x4_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_5x4_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_5x4_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_5x4_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_5x4_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_5x4_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_5x5_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_5x5_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_5x5_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_5x5_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_5x5_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_5x5_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_6x5_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_6x5_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_6x5_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_6x5_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_6x5_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_6x5_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_6x6_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_6x6_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_6x6_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_6x6_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_6x6_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_6x6_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_8x5_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x5_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x5_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_8x5_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x5_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x5_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_8x6_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x6_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x6_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_8x6_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x6_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x6_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_8x8_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x8_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x8_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ASTC_8x8_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x8_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ASTC_8x8_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_B10G11R11_UFLOAT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_B4G4R4A4_UNORM_PACK16, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B4G4R4A4_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B4G4R4A4_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_B8G8R8A8_SRGB, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_SRGB: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_SRGB: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_B8G8R8A8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_D16_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_D16_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_D32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_D32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_EAC_R11G11_SNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_EAC_R11G11_SNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_EAC_R11G11_SNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_EAC_R11G11_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_EAC_R11G11_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_EAC_R11G11_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_EAC_R11_SNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_EAC_R11_SNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_EAC_R11_SNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_EAC_R11_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_EAC_R11_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_EAC_R11_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32A32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32A32_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32A32_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R5G6B5_UNORM_PACK16, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R5G6B5_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R5G6B5_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_SRGB, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SRGB: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SRGB: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, +}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceMultiviewFeatures physicalDeviceMultiviewFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, nullptr}; + VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceMultiviewFeatures}; + VkPhysicalDeviceShaderDrawParametersFeatures physicalDeviceShaderDrawParametersFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures}; + VkPhysicalDeviceVariablePointersFeatures physicalDeviceVariablePointersFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, &physicalDeviceShaderDrawParametersFeatures}; + p->pNext = static_cast(static_cast(&physicalDeviceVariablePointersFeatures)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceMultiviewProperties physicalDeviceMultiviewProperties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, nullptr}; + p->pNext = static_cast(static_cast(&physicalDeviceMultiviewProperties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkFormatProperties3KHR formatProperties3KHR{VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr}; + p->pNext = static_cast(static_cast(&formatProperties3KHR)); + pfnCb(p, pUser); }, - { - VK_FORMAT_ASTC_12x10_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_12x10_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_12x12_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_12x12_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_4x4_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_4x4_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_5x4_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_5x4_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_5x5_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_5x5_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_6x5_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_6x5_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_6x6_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_6x6_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_8x5_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_8x5_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_8x6_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_8x6_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_8x8_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_8x8_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_B10G11R11_UFLOAT_PACK32, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_B4G4R4A4_UNORM_PACK16, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_B8G8R8A8_SRGB, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_B8G8R8A8_UNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_D16_UNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_D32_SFLOAT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_EAC_R11G11_SNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_EAC_R11G11_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_EAC_R11_SNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_EAC_R11_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } +}; +} // namespace baseline +} // namespace blocks +} // namespace VP_ANDROID_BASELINE_2022 +#endif // VP_ANDROID_baseline_2022 + +#ifdef VP_KHR_roadmap_2022 +namespace VP_KHR_ROADMAP_2022 +{ + +static const VkStructureType featureStructTypes[] = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, +}; + +static const VkStructureType propertyStructTypes[] = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, +}; + +static const VkExtensionProperties deviceExtensions[] = { + VkExtensionProperties{VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME, 1}, +}; + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.depthBiasClamp = VK_TRUE; + s->features.depthClamp = VK_TRUE; + s->features.drawIndirectFirstInstance = VK_TRUE; + s->features.fragmentStoresAndAtomics = VK_TRUE; + s->features.fullDrawIndexUint32 = VK_TRUE; + s->features.imageCubeArray = VK_TRUE; + s->features.independentBlend = VK_TRUE; + s->features.occlusionQueryPrecise = VK_TRUE; + s->features.robustBufferAccess = VK_TRUE; + s->features.sampleRateShading = VK_TRUE; + s->features.samplerAnisotropy = VK_TRUE; + s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageBufferArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageExtendedFormats = VK_TRUE; + s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *s = static_cast(static_cast(p)); + s->multiview = VK_TRUE; + s->samplerYcbcrConversion = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *s = static_cast(static_cast(p)); + s->bufferDeviceAddress = VK_TRUE; + s->descriptorBindingPartiallyBound = VK_TRUE; + s->descriptorBindingSampledImageUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageImageUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageTexelBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingUniformTexelBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingUpdateUnusedWhilePending = VK_TRUE; + s->descriptorBindingVariableDescriptorCount = VK_TRUE; + s->descriptorIndexing = VK_TRUE; + s->hostQueryReset = VK_TRUE; + s->imagelessFramebuffer = VK_TRUE; + s->runtimeDescriptorArray = VK_TRUE; + s->samplerMirrorClampToEdge = VK_TRUE; + s->scalarBlockLayout = VK_TRUE; + s->separateDepthStencilLayouts = VK_TRUE; + s->shaderSampledImageArrayNonUniformIndexing = VK_TRUE; + s->shaderStorageBufferArrayNonUniformIndexing = VK_TRUE; + s->shaderStorageImageArrayNonUniformIndexing = VK_TRUE; + s->shaderStorageTexelBufferArrayDynamicIndexing = VK_TRUE; + s->shaderStorageTexelBufferArrayNonUniformIndexing = VK_TRUE; + s->shaderSubgroupExtendedTypes = VK_TRUE; + s->shaderUniformBufferArrayNonUniformIndexing = VK_TRUE; + s->shaderUniformTexelBufferArrayDynamicIndexing = VK_TRUE; + s->shaderUniformTexelBufferArrayNonUniformIndexing = VK_TRUE; + s->subgroupBroadcastDynamicId = VK_TRUE; + s->timelineSemaphore = VK_TRUE; + s->uniformBufferStandardLayout = VK_TRUE; + s->vulkanMemoryModel = VK_TRUE; + s->vulkanMemoryModelDeviceScope = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + { + VkPhysicalDeviceVulkan13Features *s = static_cast(static_cast(p)); + s->computeFullSubgroups = VK_TRUE; + s->descriptorBindingInlineUniformBlockUpdateAfterBind = VK_TRUE; + s->dynamicRendering = VK_TRUE; + s->inlineUniformBlock = VK_TRUE; + s->maintenance4 = VK_TRUE; + s->pipelineCreationCacheControl = VK_TRUE; + s->robustImageAccess = VK_TRUE; + s->shaderDemoteToHelperInvocation = VK_TRUE; + s->shaderIntegerDotProduct = VK_TRUE; + s->shaderTerminateInvocation = VK_TRUE; + s->shaderZeroInitializeWorkgroupMemory = VK_TRUE; + s->subgroupSizeControl = VK_TRUE; + s->synchronization2 = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthBiasClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.drawIndirectFirstInstance == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fragmentStoresAndAtomics == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fullDrawIndexUint32 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.imageCubeArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.independentBlend == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.occlusionQueryPrecise == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.occlusionQueryPrecise == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.occlusionQueryPrecise == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.sampleRateShading == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.samplerAnisotropy == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderSampledImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageExtendedFormats == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *prettify_VkPhysicalDeviceVulkan11Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::multiview == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->samplerYcbcrConversion == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->samplerYcbcrConversion == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::samplerYcbcrConversion == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *prettify_VkPhysicalDeviceVulkan12Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->bufferDeviceAddress == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->bufferDeviceAddress == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::bufferDeviceAddress == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingPartiallyBound == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingPartiallyBound == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingPartiallyBound == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingSampledImageUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageImageUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUpdateUnusedWhilePending == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUpdateUnusedWhilePending == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingUpdateUnusedWhilePending == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingVariableDescriptorCount == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingVariableDescriptorCount == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingVariableDescriptorCount == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::hostQueryReset == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::imagelessFramebuffer == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->runtimeDescriptorArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->runtimeDescriptorArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::runtimeDescriptorArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->samplerMirrorClampToEdge == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->samplerMirrorClampToEdge == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::samplerMirrorClampToEdge == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->scalarBlockLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->scalarBlockLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::scalarBlockLayout == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::separateDepthStencilLayouts == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderSampledImageArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderSampledImageArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderSampledImageArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageBufferArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageImageArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageImageArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageImageArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderSubgroupExtendedTypes == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderSubgroupExtendedTypes == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderSubgroupExtendedTypes == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderUniformBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderUniformBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderUniformBufferArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->subgroupBroadcastDynamicId == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->subgroupBroadcastDynamicId == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::subgroupBroadcastDynamicId == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::timelineSemaphore == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::uniformBufferStandardLayout == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModel == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModel == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::vulkanMemoryModel == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModelDeviceScope == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModelDeviceScope == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::vulkanMemoryModelDeviceScope == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + { + VkPhysicalDeviceVulkan13Features *prettify_VkPhysicalDeviceVulkan13Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->computeFullSubgroups == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->computeFullSubgroups == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::computeFullSubgroups == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->dynamicRendering == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->dynamicRendering == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::dynamicRendering == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->inlineUniformBlock == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->inlineUniformBlock == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::inlineUniformBlock == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->maintenance4 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->maintenance4 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::maintenance4 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->pipelineCreationCacheControl == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->pipelineCreationCacheControl == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::pipelineCreationCacheControl == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->robustImageAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->robustImageAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::robustImageAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderDemoteToHelperInvocation == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderDemoteToHelperInvocation == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderDemoteToHelperInvocation == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderIntegerDotProduct == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderIntegerDotProduct == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderIntegerDotProduct == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderTerminateInvocation == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderTerminateInvocation == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderTerminateInvocation == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderZeroInitializeWorkgroupMemory == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderZeroInitializeWorkgroupMemory == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderZeroInitializeWorkgroupMemory == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->subgroupSizeControl == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->subgroupSizeControl == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::subgroupSizeControl == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->synchronization2 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->synchronization2 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::synchronization2 == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; }, - { - VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, - { - VK_FORMAT_R16G16B16A16_SFLOAT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } +}; + +namespace blocks +{ +namespace vulkan10requirements +{ + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.robustBufferAccess = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; }, - { - VK_FORMAT_R16G16B16A16_SINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, - { - VK_FORMAT_R16G16B16A16_SNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - } break; - default: break; - } - return ret; - } +}; +} // namespace vulkan10requirements +namespace vulkan10requirements_roadmap2022 +{ + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.depthBiasClamp = VK_TRUE; + s->features.depthClamp = VK_TRUE; + s->features.drawIndirectFirstInstance = VK_TRUE; + s->features.fragmentStoresAndAtomics = VK_TRUE; + s->features.fullDrawIndexUint32 = VK_TRUE; + s->features.imageCubeArray = VK_TRUE; + s->features.independentBlend = VK_TRUE; + s->features.occlusionQueryPrecise = VK_TRUE; + s->features.sampleRateShading = VK_TRUE; + s->features.samplerAnisotropy = VK_TRUE; + s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageBufferArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageExtendedFormats = VK_TRUE; + s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthBiasClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.drawIndirectFirstInstance == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fragmentStoresAndAtomics == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fullDrawIndexUint32 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.imageCubeArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.independentBlend == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.occlusionQueryPrecise == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.occlusionQueryPrecise == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.occlusionQueryPrecise == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.sampleRateShading == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.samplerAnisotropy == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderSampledImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageExtendedFormats == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *s = static_cast(static_cast(p)); + s->properties.limits.bufferImageGranularity = 4096; + s->properties.limits.maxColorAttachments = 7; + s->properties.limits.maxComputeWorkGroupInvocations = 256; + s->properties.limits.maxComputeWorkGroupSize[0] = 256; + s->properties.limits.maxComputeWorkGroupSize[1] = 256; + s->properties.limits.maxComputeWorkGroupSize[2] = 64; + s->properties.limits.maxDescriptorSetSampledImages = 1800; + s->properties.limits.maxDescriptorSetSamplers = 576; + s->properties.limits.maxDescriptorSetStorageBuffers = 96; + s->properties.limits.maxDescriptorSetStorageImages = 144; + s->properties.limits.maxDescriptorSetUniformBuffers = 90; + s->properties.limits.maxFragmentCombinedOutputResources = 16; + s->properties.limits.maxImageArrayLayers = 2048; + s->properties.limits.maxImageDimension1D = 8192; + s->properties.limits.maxImageDimension2D = 8192; + s->properties.limits.maxImageDimensionCube = 8192; + s->properties.limits.maxPerStageDescriptorSampledImages = 200; + s->properties.limits.maxPerStageDescriptorSamplers = 64; + s->properties.limits.maxPerStageDescriptorStorageBuffers = 30; + s->properties.limits.maxPerStageDescriptorStorageImages = 16; + s->properties.limits.maxPerStageDescriptorUniformBuffers = 15; + s->properties.limits.maxPerStageResources = 200; + s->properties.limits.maxSamplerLodBias = 14; + s->properties.limits.maxUniformBufferRange = 65536; + s->properties.limits.mipmapPrecisionBits = 6; + s->properties.limits.standardSampleLocations = VK_TRUE; + s->properties.limits.subTexelPrecisionBits = 8; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *prettify_VkPhysicalDeviceProperties2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity <= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity <= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.bufferImageGranularity <= 4096"); + ret = ret && ((4096 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0); + VP_DEBUG_COND_MSG(!((4096 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0), "Unsupported properties condition: (4096 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxColorAttachments >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupInvocations >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[0] >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[1] >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[2] >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 1800); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 1800), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSampledImages >= 1800"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 576); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 576), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSamplers >= 576"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 96); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 96), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffers >= 96"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 144); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 144), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageImages >= 144"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 90); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 90), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffers >= 90"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentCombinedOutputResources >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageArrayLayers >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 8192); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 8192), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension1D >= 8192"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 8192); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 8192), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension2D >= 8192"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 8192); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 8192), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimensionCube >= 8192"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 200); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 200), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSampledImages >= 200"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSamplers >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 30); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 30), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageBuffers >= 30"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageImages >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 15); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 15), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorUniformBuffers >= 15"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 200); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 200), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageResources >= 200"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 14); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 14), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerLodBias >= 14"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 65536); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 65536), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxUniformBufferRange >= 65536"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 6); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 6), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.mipmapPrecisionBits >= 6"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.standardSampleLocations >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.standardSampleLocations >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.standardSampleLocations >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subTexelPrecisionBits >= 8"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, - { - VK_FORMAT_R16G16B16A16_UINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } +}; +} // namespace vulkan10requirements_roadmap2022 +namespace vulkan11requirements +{ + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *s = static_cast(static_cast(p)); + s->multiview = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *prettify_VkPhysicalDeviceVulkan11Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::multiview == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + { + VkPhysicalDeviceVulkan11Properties *s = static_cast(static_cast(p)); + s->maxMultiviewInstanceIndex = 134217727; + s->maxMultiviewViewCount = 6; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + { + VkPhysicalDeviceVulkan11Properties *prettify_VkPhysicalDeviceVulkan11Properties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewInstanceIndex >= 134217727); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewInstanceIndex >= 134217727), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::maxMultiviewInstanceIndex >= 134217727"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewViewCount >= 6); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewViewCount >= 6), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::maxMultiviewViewCount >= 6"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, - { - VK_FORMAT_R16G16_SFLOAT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } +}; +} // namespace vulkan11requirements +namespace vulkan11requirements_roadmap2022 +{ + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *s = static_cast(static_cast(p)); + s->samplerYcbcrConversion = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *prettify_VkPhysicalDeviceVulkan11Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->samplerYcbcrConversion == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->samplerYcbcrConversion == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::samplerYcbcrConversion == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + { + VkPhysicalDeviceVulkan11Properties *s = static_cast(static_cast(p)); + s->subgroupSize = 4; + s->subgroupSupportedOperations |= (VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT | VK_SUBGROUP_FEATURE_QUAD_BIT); + s->subgroupSupportedStages |= (VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_FRAGMENT_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + { + VkPhysicalDeviceVulkan11Properties *prettify_VkPhysicalDeviceVulkan11Properties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize >= 4), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::subgroupSize >= 4"); + ret = ret && ((prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize & (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize & (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize & (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize - 1)) == 0"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT | VK_SUBGROUP_FEATURE_QUAD_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT | VK_SUBGROUP_FEATURE_QUAD_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::subgroupSupportedOperations contains (VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT | VK_SUBGROUP_FEATURE_QUAD_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedStages, (VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_FRAGMENT_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedStages, (VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_FRAGMENT_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::subgroupSupportedStages contains (VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_FRAGMENT_BIT)"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, - { - VK_FORMAT_R16G16_SINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } +}; +} // namespace vulkan11requirements_roadmap2022 +namespace vulkan12requirements +{ + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *s = static_cast(static_cast(p)); + s->hostQueryReset = VK_TRUE; + s->imagelessFramebuffer = VK_TRUE; + s->separateDepthStencilLayouts = VK_TRUE; + s->shaderSubgroupExtendedTypes = VK_TRUE; + s->subgroupBroadcastDynamicId = VK_TRUE; + s->timelineSemaphore = VK_TRUE; + s->uniformBufferStandardLayout = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *prettify_VkPhysicalDeviceVulkan12Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::hostQueryReset == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::imagelessFramebuffer == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::separateDepthStencilLayouts == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderSubgroupExtendedTypes == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderSubgroupExtendedTypes == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderSubgroupExtendedTypes == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->subgroupBroadcastDynamicId == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->subgroupBroadcastDynamicId == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::subgroupBroadcastDynamicId == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::timelineSemaphore == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::uniformBufferStandardLayout == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + { + VkPhysicalDeviceVulkan12Properties *s = static_cast(static_cast(p)); + s->maxTimelineSemaphoreValueDifference = 2147483647; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + { + VkPhysicalDeviceVulkan12Properties *prettify_VkPhysicalDeviceVulkan12Properties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxTimelineSemaphoreValueDifference >= 2147483647); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxTimelineSemaphoreValueDifference >= 2147483647), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxTimelineSemaphoreValueDifference >= 2147483647"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, - { - VK_FORMAT_R16G16_SNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - } break; - default: break; - } - return ret; - } +}; +} // namespace vulkan12requirements +namespace vulkan12requirements_roadmap2022 +{ + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *s = static_cast(static_cast(p)); + s->descriptorBindingPartiallyBound = VK_TRUE; + s->descriptorBindingSampledImageUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageImageUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageTexelBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingUniformTexelBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingUpdateUnusedWhilePending = VK_TRUE; + s->descriptorBindingVariableDescriptorCount = VK_TRUE; + s->descriptorIndexing = VK_TRUE; + s->runtimeDescriptorArray = VK_TRUE; + s->samplerMirrorClampToEdge = VK_TRUE; + s->scalarBlockLayout = VK_TRUE; + s->shaderSampledImageArrayNonUniformIndexing = VK_TRUE; + s->shaderStorageBufferArrayNonUniformIndexing = VK_TRUE; + s->shaderStorageImageArrayNonUniformIndexing = VK_TRUE; + s->shaderStorageTexelBufferArrayDynamicIndexing = VK_TRUE; + s->shaderStorageTexelBufferArrayNonUniformIndexing = VK_TRUE; + s->shaderUniformBufferArrayNonUniformIndexing = VK_TRUE; + s->shaderUniformTexelBufferArrayDynamicIndexing = VK_TRUE; + s->shaderUniformTexelBufferArrayNonUniformIndexing = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *prettify_VkPhysicalDeviceVulkan12Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingPartiallyBound == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingPartiallyBound == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingPartiallyBound == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingSampledImageUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageImageUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUpdateUnusedWhilePending == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUpdateUnusedWhilePending == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingUpdateUnusedWhilePending == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingVariableDescriptorCount == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingVariableDescriptorCount == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingVariableDescriptorCount == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->runtimeDescriptorArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->runtimeDescriptorArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::runtimeDescriptorArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->samplerMirrorClampToEdge == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->samplerMirrorClampToEdge == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::samplerMirrorClampToEdge == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->scalarBlockLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->scalarBlockLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::scalarBlockLayout == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderSampledImageArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderSampledImageArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderSampledImageArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageBufferArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageImageArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageImageArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageImageArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderUniformBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderUniformBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderUniformBufferArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + { + VkPhysicalDeviceVulkan12Properties *s = static_cast(static_cast(p)); + s->maxDescriptorSetUpdateAfterBindInputAttachments = 7; + s->maxDescriptorSetUpdateAfterBindSampledImages = 500000; + s->maxDescriptorSetUpdateAfterBindSamplers = 500000; + s->maxDescriptorSetUpdateAfterBindStorageBuffers = 500000; + s->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = 4; + s->maxDescriptorSetUpdateAfterBindStorageImages = 500000; + s->maxDescriptorSetUpdateAfterBindUniformBuffers = 72; + s->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = 8; + s->maxPerStageDescriptorUpdateAfterBindInputAttachments = 7; + s->maxPerStageDescriptorUpdateAfterBindSampledImages = 500000; + s->maxPerStageDescriptorUpdateAfterBindSamplers = 500000; + s->maxPerStageDescriptorUpdateAfterBindStorageBuffers = 500000; + s->maxPerStageDescriptorUpdateAfterBindStorageImages = 500000; + s->maxPerStageDescriptorUpdateAfterBindUniformBuffers = 12; + s->maxPerStageUpdateAfterBindResources = 500000; + s->shaderSignedZeroInfNanPreserveFloat16 = VK_TRUE; + s->shaderSignedZeroInfNanPreserveFloat32 = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + { + VkPhysicalDeviceVulkan12Properties *prettify_VkPhysicalDeviceVulkan12Properties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindInputAttachments >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindInputAttachments >= 7), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindInputAttachments >= 7"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSampledImages >= 500000); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSampledImages >= 500000), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindSampledImages >= 500000"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSamplers >= 500000); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSamplers >= 500000), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindSamplers >= 500000"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffers >= 500000); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffers >= 500000), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindStorageBuffers >= 500000"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 4), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 4"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageImages >= 500000); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageImages >= 500000), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindStorageImages >= 500000"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffers >= 72); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffers >= 72), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindUniformBuffers >= 72"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 8), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 8"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindInputAttachments >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindInputAttachments >= 7), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindInputAttachments >= 7"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSampledImages >= 500000); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSampledImages >= 500000), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindSampledImages >= 500000"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSamplers >= 500000); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSamplers >= 500000), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindSamplers >= 500000"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 500000); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 500000), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 500000"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageImages >= 500000); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageImages >= 500000), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindStorageImages >= 500000"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 12); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 12), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 12"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageUpdateAfterBindResources >= 500000); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageUpdateAfterBindResources >= 500000), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageUpdateAfterBindResources >= 500000"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat16 >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat16 >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderSignedZeroInfNanPreserveFloat16 >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat32 >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat32 >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderSignedZeroInfNanPreserveFloat32 >= VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, - { - VK_FORMAT_R16G16_UINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } +}; +} // namespace vulkan12requirements_roadmap2022 +namespace vulkan13requirements +{ + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *s = static_cast(static_cast(p)); + s->bufferDeviceAddress = VK_TRUE; + s->vulkanMemoryModel = VK_TRUE; + s->vulkanMemoryModelDeviceScope = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + { + VkPhysicalDeviceVulkan13Features *s = static_cast(static_cast(p)); + s->computeFullSubgroups = VK_TRUE; + s->dynamicRendering = VK_TRUE; + s->inlineUniformBlock = VK_TRUE; + s->maintenance4 = VK_TRUE; + s->pipelineCreationCacheControl = VK_TRUE; + s->robustImageAccess = VK_TRUE; + s->shaderDemoteToHelperInvocation = VK_TRUE; + s->shaderIntegerDotProduct = VK_TRUE; + s->shaderTerminateInvocation = VK_TRUE; + s->shaderZeroInitializeWorkgroupMemory = VK_TRUE; + s->subgroupSizeControl = VK_TRUE; + s->synchronization2 = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *prettify_VkPhysicalDeviceVulkan12Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->bufferDeviceAddress == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->bufferDeviceAddress == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::bufferDeviceAddress == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModel == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModel == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::vulkanMemoryModel == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModelDeviceScope == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModelDeviceScope == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::vulkanMemoryModelDeviceScope == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + { + VkPhysicalDeviceVulkan13Features *prettify_VkPhysicalDeviceVulkan13Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->computeFullSubgroups == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->computeFullSubgroups == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::computeFullSubgroups == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->dynamicRendering == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->dynamicRendering == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::dynamicRendering == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->inlineUniformBlock == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->inlineUniformBlock == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::inlineUniformBlock == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->maintenance4 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->maintenance4 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::maintenance4 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->pipelineCreationCacheControl == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->pipelineCreationCacheControl == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::pipelineCreationCacheControl == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->robustImageAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->robustImageAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::robustImageAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderDemoteToHelperInvocation == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderDemoteToHelperInvocation == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderDemoteToHelperInvocation == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderIntegerDotProduct == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderIntegerDotProduct == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderIntegerDotProduct == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderTerminateInvocation == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderTerminateInvocation == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderTerminateInvocation == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderZeroInitializeWorkgroupMemory == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderZeroInitializeWorkgroupMemory == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderZeroInitializeWorkgroupMemory == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->subgroupSizeControl == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->subgroupSizeControl == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::subgroupSizeControl == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->synchronization2 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->synchronization2 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::synchronization2 == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: + { + VkPhysicalDeviceVulkan13Properties *s = static_cast(static_cast(p)); + s->maxBufferSize = 1073741824; + s->maxDescriptorSetInlineUniformBlocks = 4; + s->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = 4; + s->maxInlineUniformBlockSize = 256; + s->maxInlineUniformTotalSize = 256; + s->maxPerStageDescriptorInlineUniformBlocks = 4; + s->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = 4; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: + { + VkPhysicalDeviceVulkan13Properties *prettify_VkPhysicalDeviceVulkan13Properties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->maxBufferSize >= 1073741824); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->maxBufferSize >= 1073741824), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::maxBufferSize >= 1073741824"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->maxDescriptorSetInlineUniformBlocks >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->maxDescriptorSetInlineUniformBlocks >= 4), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::maxDescriptorSetInlineUniformBlocks >= 4"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->maxDescriptorSetUpdateAfterBindInlineUniformBlocks >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->maxDescriptorSetUpdateAfterBindInlineUniformBlocks >= 4), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::maxDescriptorSetUpdateAfterBindInlineUniformBlocks >= 4"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->maxInlineUniformBlockSize >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->maxInlineUniformBlockSize >= 256), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::maxInlineUniformBlockSize >= 256"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->maxInlineUniformTotalSize >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->maxInlineUniformTotalSize >= 256), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::maxInlineUniformTotalSize >= 256"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->maxPerStageDescriptorInlineUniformBlocks >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->maxPerStageDescriptorInlineUniformBlocks >= 4), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::maxPerStageDescriptorInlineUniformBlocks >= 4"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks >= 4), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks >= 4"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, - { - VK_FORMAT_R16_SFLOAT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } +}; +} // namespace vulkan13requirements +namespace vulkan13requirements_roadmap2022 +{ + +static const VkExtensionProperties deviceExtensions[] = { + VkExtensionProperties{VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME, 1}, +}; + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + { + VkPhysicalDeviceVulkan13Features *s = static_cast(static_cast(p)); + s->descriptorBindingInlineUniformBlockUpdateAfterBind = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + { + VkPhysicalDeviceVulkan13Features *prettify_VkPhysicalDeviceVulkan13Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; }, - { - VK_FORMAT_R16_SINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, - { - VK_FORMAT_R16_SNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - } break; - default: break; - } - return ret; - } +}; +} // namespace vulkan13requirements_roadmap2022 +} // namespace blocks +} // namespace VP_KHR_ROADMAP_2022 +#endif // VP_KHR_roadmap_2022 + +#ifdef VP_KHR_roadmap_2024 +namespace VP_KHR_ROADMAP_2024 +{ + +static const VkStructureType featureStructTypes[] = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, +}; + +static const VkStructureType propertyStructTypes[] = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, +}; + +static const VkExtensionProperties deviceExtensions[] = { + VkExtensionProperties{VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_5_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAP_MEMORY_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, 1}, +}; + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.depthBiasClamp = VK_TRUE; + s->features.depthClamp = VK_TRUE; + s->features.drawIndirectFirstInstance = VK_TRUE; + s->features.fragmentStoresAndAtomics = VK_TRUE; + s->features.fullDrawIndexUint32 = VK_TRUE; + s->features.imageCubeArray = VK_TRUE; + s->features.independentBlend = VK_TRUE; + s->features.multiDrawIndirect = VK_TRUE; + s->features.occlusionQueryPrecise = VK_TRUE; + s->features.robustBufferAccess = VK_TRUE; + s->features.sampleRateShading = VK_TRUE; + s->features.samplerAnisotropy = VK_TRUE; + s->features.shaderImageGatherExtended = VK_TRUE; + s->features.shaderInt16 = VK_TRUE; + s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageBufferArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageExtendedFormats = VK_TRUE; + s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *s = static_cast(static_cast(p)); + s->multiview = VK_TRUE; + s->samplerYcbcrConversion = VK_TRUE; + s->shaderDrawParameters = VK_TRUE; + s->storageBuffer16BitAccess = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *s = static_cast(static_cast(p)); + s->bufferDeviceAddress = VK_TRUE; + s->descriptorBindingPartiallyBound = VK_TRUE; + s->descriptorBindingSampledImageUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageImageUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageTexelBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingUniformTexelBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingUpdateUnusedWhilePending = VK_TRUE; + s->descriptorBindingVariableDescriptorCount = VK_TRUE; + s->descriptorIndexing = VK_TRUE; + s->hostQueryReset = VK_TRUE; + s->imagelessFramebuffer = VK_TRUE; + s->runtimeDescriptorArray = VK_TRUE; + s->samplerMirrorClampToEdge = VK_TRUE; + s->scalarBlockLayout = VK_TRUE; + s->separateDepthStencilLayouts = VK_TRUE; + s->shaderFloat16 = VK_TRUE; + s->shaderInt8 = VK_TRUE; + s->shaderSampledImageArrayNonUniformIndexing = VK_TRUE; + s->shaderStorageBufferArrayNonUniformIndexing = VK_TRUE; + s->shaderStorageImageArrayNonUniformIndexing = VK_TRUE; + s->shaderStorageTexelBufferArrayDynamicIndexing = VK_TRUE; + s->shaderStorageTexelBufferArrayNonUniformIndexing = VK_TRUE; + s->shaderSubgroupExtendedTypes = VK_TRUE; + s->shaderUniformBufferArrayNonUniformIndexing = VK_TRUE; + s->shaderUniformTexelBufferArrayDynamicIndexing = VK_TRUE; + s->shaderUniformTexelBufferArrayNonUniformIndexing = VK_TRUE; + s->storageBuffer8BitAccess = VK_TRUE; + s->subgroupBroadcastDynamicId = VK_TRUE; + s->timelineSemaphore = VK_TRUE; + s->uniformBufferStandardLayout = VK_TRUE; + s->vulkanMemoryModel = VK_TRUE; + s->vulkanMemoryModelDeviceScope = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + { + VkPhysicalDeviceVulkan13Features *s = static_cast(static_cast(p)); + s->computeFullSubgroups = VK_TRUE; + s->descriptorBindingInlineUniformBlockUpdateAfterBind = VK_TRUE; + s->dynamicRendering = VK_TRUE; + s->inlineUniformBlock = VK_TRUE; + s->maintenance4 = VK_TRUE; + s->pipelineCreationCacheControl = VK_TRUE; + s->robustImageAccess = VK_TRUE; + s->shaderDemoteToHelperInvocation = VK_TRUE; + s->shaderIntegerDotProduct = VK_TRUE; + s->shaderTerminateInvocation = VK_TRUE; + s->shaderZeroInitializeWorkgroupMemory = VK_TRUE; + s->subgroupSizeControl = VK_TRUE; + s->synchronization2 = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthBiasClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.drawIndirectFirstInstance == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fragmentStoresAndAtomics == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fullDrawIndexUint32 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.imageCubeArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.independentBlend == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.multiDrawIndirect == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.multiDrawIndirect == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.multiDrawIndirect == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.occlusionQueryPrecise == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.occlusionQueryPrecise == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.occlusionQueryPrecise == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.sampleRateShading == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.samplerAnisotropy == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderImageGatherExtended == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderImageGatherExtended == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderImageGatherExtended == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderInt16 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderInt16 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderInt16 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderSampledImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageExtendedFormats == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *prettify_VkPhysicalDeviceVulkan11Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::multiview == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->samplerYcbcrConversion == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->samplerYcbcrConversion == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::samplerYcbcrConversion == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->shaderDrawParameters == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->shaderDrawParameters == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::shaderDrawParameters == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->storageBuffer16BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->storageBuffer16BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::storageBuffer16BitAccess == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *prettify_VkPhysicalDeviceVulkan12Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->bufferDeviceAddress == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->bufferDeviceAddress == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::bufferDeviceAddress == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingPartiallyBound == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingPartiallyBound == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingPartiallyBound == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingSampledImageUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageImageUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUpdateUnusedWhilePending == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUpdateUnusedWhilePending == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingUpdateUnusedWhilePending == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingVariableDescriptorCount == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingVariableDescriptorCount == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingVariableDescriptorCount == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::hostQueryReset == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::imagelessFramebuffer == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->runtimeDescriptorArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->runtimeDescriptorArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::runtimeDescriptorArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->samplerMirrorClampToEdge == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->samplerMirrorClampToEdge == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::samplerMirrorClampToEdge == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->scalarBlockLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->scalarBlockLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::scalarBlockLayout == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::separateDepthStencilLayouts == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderFloat16 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderFloat16 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderFloat16 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderInt8 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderInt8 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderInt8 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderSampledImageArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderSampledImageArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderSampledImageArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageBufferArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageImageArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageImageArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageImageArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderSubgroupExtendedTypes == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderSubgroupExtendedTypes == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderSubgroupExtendedTypes == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderUniformBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderUniformBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderUniformBufferArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->storageBuffer8BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->storageBuffer8BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::storageBuffer8BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->subgroupBroadcastDynamicId == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->subgroupBroadcastDynamicId == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::subgroupBroadcastDynamicId == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::timelineSemaphore == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::uniformBufferStandardLayout == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModel == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModel == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::vulkanMemoryModel == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModelDeviceScope == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModelDeviceScope == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::vulkanMemoryModelDeviceScope == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + { + VkPhysicalDeviceVulkan13Features *prettify_VkPhysicalDeviceVulkan13Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->computeFullSubgroups == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->computeFullSubgroups == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::computeFullSubgroups == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->dynamicRendering == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->dynamicRendering == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::dynamicRendering == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->inlineUniformBlock == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->inlineUniformBlock == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::inlineUniformBlock == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->maintenance4 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->maintenance4 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::maintenance4 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->pipelineCreationCacheControl == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->pipelineCreationCacheControl == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::pipelineCreationCacheControl == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->robustImageAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->robustImageAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::robustImageAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderDemoteToHelperInvocation == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderDemoteToHelperInvocation == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderDemoteToHelperInvocation == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderIntegerDotProduct == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderIntegerDotProduct == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderIntegerDotProduct == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderTerminateInvocation == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderTerminateInvocation == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderTerminateInvocation == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderZeroInitializeWorkgroupMemory == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderZeroInitializeWorkgroupMemory == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderZeroInitializeWorkgroupMemory == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->subgroupSizeControl == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->subgroupSizeControl == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::subgroupSizeControl == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->synchronization2 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->synchronization2 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::synchronization2 == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; }, - { - VK_FORMAT_R16_UINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); }, - { - VK_FORMAT_R16_UNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); }, - { - VK_FORMAT_R32G32B32A32_SFLOAT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); }, - { - VK_FORMAT_R32G32B32A32_SINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, - { - VK_FORMAT_R32G32B32A32_UINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } +}; + +namespace blocks +{ +namespace vulkan10requirements_roadmap2024 +{ + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.multiDrawIndirect = VK_TRUE; + s->features.shaderImageGatherExtended = VK_TRUE; + s->features.shaderInt16 = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.multiDrawIndirect == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.multiDrawIndirect == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.multiDrawIndirect == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderImageGatherExtended == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderImageGatherExtended == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderImageGatherExtended == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderInt16 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderInt16 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderInt16 == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *s = static_cast(static_cast(p)); + s->properties.limits.maxBoundDescriptorSets = 7; + s->properties.limits.maxColorAttachments = 8; + s->properties.limits.timestampComputeAndGraphics = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *prettify_VkPhysicalDeviceProperties2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxBoundDescriptorSets >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxColorAttachments >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.timestampComputeAndGraphics >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.timestampComputeAndGraphics >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.timestampComputeAndGraphics >= VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); }, - { - VK_FORMAT_R32G32_SFLOAT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); }, - { - VK_FORMAT_R32G32_SINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); }, - { - VK_FORMAT_R32G32_UINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, - { - VK_FORMAT_R32_SFLOAT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } +}; +} // namespace vulkan10requirements_roadmap2024 +namespace vulkan11requirements_roadmap2024 +{ + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *s = static_cast(static_cast(p)); + s->shaderDrawParameters = VK_TRUE; + s->storageBuffer16BitAccess = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *prettify_VkPhysicalDeviceVulkan11Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->shaderDrawParameters == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->shaderDrawParameters == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::shaderDrawParameters == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->storageBuffer16BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->storageBuffer16BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::storageBuffer16BitAccess == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; }, - { - VK_FORMAT_R32_SINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); }, - { - VK_FORMAT_R32_UINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); }, - { - VK_FORMAT_R5G6B5_UNORM_PACK16, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); }, - { - VK_FORMAT_R8G8B8A8_SINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, - { - VK_FORMAT_R8G8B8A8_SNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } +}; +} // namespace vulkan11requirements_roadmap2024 +namespace vulkan12requirements_roadmap2024 +{ + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *s = static_cast(static_cast(p)); + s->shaderFloat16 = VK_TRUE; + s->shaderInt8 = VK_TRUE; + s->storageBuffer8BitAccess = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *prettify_VkPhysicalDeviceVulkan12Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderFloat16 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderFloat16 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderFloat16 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderInt8 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderInt8 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderInt8 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->storageBuffer8BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->storageBuffer8BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::storageBuffer8BitAccess == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + { + VkPhysicalDeviceVulkan12Properties *s = static_cast(static_cast(p)); + s->shaderRoundingModeRTEFloat16 = VK_TRUE; + s->shaderRoundingModeRTEFloat32 = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + { + VkPhysicalDeviceVulkan12Properties *prettify_VkPhysicalDeviceVulkan12Properties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat16 >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat16 >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTEFloat16 >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat32 >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat32 >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTEFloat32 >= VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); }, - { - VK_FORMAT_R8G8B8A8_SRGB, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); }, - { - VK_FORMAT_R8G8B8A8_UINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); }, - { - VK_FORMAT_R8G8B8A8_UNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, - { - VK_FORMAT_R8G8_SINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } +}; +} // namespace vulkan12requirements_roadmap2024 +namespace vulkan13requirements_roadmap2024 +{ + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; }, - { - VK_FORMAT_R8G8_SNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; }, - { - VK_FORMAT_R8G8_UINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); }, - { - VK_FORMAT_R8G8_UNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); }, - { - VK_FORMAT_R8_SINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); }, - { - VK_FORMAT_R8_SNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, - { - VK_FORMAT_R8_UINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } +}; +} // namespace vulkan13requirements_roadmap2024 +namespace vulkanextensionrequirements_roadmap2024 +{ + +static const VkExtensionProperties deviceExtensions[] = { + VkExtensionProperties{VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_5_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAP_MEMORY_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, 1}, +}; + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; }, - { - VK_FORMAT_R8_UNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; }, -}; + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - p->pNext = static_cast(static_cast(nullptr)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - p->pNext = static_cast(static_cast(nullptr)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkFormatProperties3KHR formatProperties3KHR{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr }; - p->pNext = static_cast(static_cast(&formatProperties3KHR)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, }; -} //namespace baseline -} // namespace VP_ANDROID_BASELINE_2021 -#endif // VP_ANDROID_baseline_2021 +} // namespace vulkanextensionrequirements_roadmap2024 +} // namespace blocks +} // namespace VP_KHR_ROADMAP_2024 +#endif // VP_KHR_roadmap_2024 -#ifdef VP_ANDROID_baseline_2022 -namespace VP_ANDROID_BASELINE_2022 { +#ifdef VP_LUNARG_desktop_baseline_2022 +namespace VP_LUNARG_DESKTOP_BASELINE_2022 +{ static const VkStructureType featureStructTypes[] = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, }; static const VkStructureType propertyStructTypes[] = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, }; static const VkStructureType formatStructTypes[] = { @@ -4319,3757 +12158,16313 @@ static const VkStructureType formatStructTypes[] = { VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, }; -static const VkExtensionProperties instanceExtensions[] = { - VkExtensionProperties{ VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SURFACE_EXTENSION_NAME, 1 }, -}; - static const VkExtensionProperties deviceExtensions[] = { - VkExtensionProperties{ VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SWAPCHAIN_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, 1 }, + VkExtensionProperties{VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_MEMORY_BUDGET_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_ROBUSTNESS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_KHR_16BIT_STORAGE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_8BIT_STORAGE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_BIND_MEMORY_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DEVICE_GROUP_EXTENSION_NAME, 4}, + VkExtensionProperties{VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_KHR_MAINTENANCE_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_3_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MULTIVIEW_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SWAPCHAIN_EXTENSION_NAME, 70}, + VkExtensionProperties{VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, 1}, }; static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.depthBiasClamp = VK_TRUE; - s->features.fragmentStoresAndAtomics = VK_TRUE; - s->features.fullDrawIndexUint32 = VK_TRUE; - s->features.imageCubeArray = VK_TRUE; - s->features.independentBlend = VK_TRUE; - s->features.largePoints = VK_TRUE; - s->features.robustBufferAccess = VK_TRUE; - s->features.sampleRateShading = VK_TRUE; - s->features.shaderInt16 = VK_TRUE; - s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; - s->features.shaderStorageBufferArrayDynamicIndexing = VK_TRUE; - s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; - s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; - s->features.textureCompressionASTC_LDR = VK_TRUE; - s->features.textureCompressionETC2 = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: { - VkPhysicalDeviceMultiviewFeatures* s = static_cast(static_cast(p)); - s->multiview = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: { - VkPhysicalDeviceSamplerYcbcrConversionFeatures* s = static_cast(static_cast(p)); - s->samplerYcbcrConversion = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: { - VkPhysicalDeviceShaderDrawParametersFeatures* s = static_cast(static_cast(p)); - s->shaderDrawParameters = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: { - VkPhysicalDeviceVariablePointersFeatures* s = static_cast(static_cast(p)); - s->variablePointers = VK_TRUE; - s->variablePointersStorageBuffer = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.depthBiasClamp == VK_TRUE); - ret = ret && (s->features.fragmentStoresAndAtomics == VK_TRUE); - ret = ret && (s->features.fullDrawIndexUint32 == VK_TRUE); - ret = ret && (s->features.imageCubeArray == VK_TRUE); - ret = ret && (s->features.independentBlend == VK_TRUE); - ret = ret && (s->features.largePoints == VK_TRUE); - ret = ret && (s->features.robustBufferAccess == VK_TRUE); - ret = ret && (s->features.sampleRateShading == VK_TRUE); - ret = ret && (s->features.shaderInt16 == VK_TRUE); - ret = ret && (s->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.textureCompressionASTC_LDR == VK_TRUE); - ret = ret && (s->features.textureCompressionETC2 == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: { - VkPhysicalDeviceMultiviewFeatures* s = static_cast(static_cast(p)); - ret = ret && (s->multiview == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: { - VkPhysicalDeviceSamplerYcbcrConversionFeatures* s = static_cast(static_cast(p)); - ret = ret && (s->samplerYcbcrConversion == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: { - VkPhysicalDeviceShaderDrawParametersFeatures* s = static_cast(static_cast(p)); - ret = ret && (s->shaderDrawParameters == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: { - VkPhysicalDeviceVariablePointersFeatures* s = static_cast(static_cast(p)); - ret = ret && (s->variablePointers == VK_TRUE); - ret = ret && (s->variablePointersStorageBuffer == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR: + { + VkPhysicalDevice16BitStorageFeaturesKHR *s = static_cast(static_cast(p)); + s->storageBuffer16BitAccess = VK_TRUE; + s->uniformAndStorageBuffer16BitAccess = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: + { + VkPhysicalDevice8BitStorageFeaturesKHR *s = static_cast(static_cast(p)); + s->storageBuffer8BitAccess = VK_TRUE; + s->uniformAndStorageBuffer8BitAccess = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: + { + VkPhysicalDeviceDescriptorIndexingFeaturesEXT *s = static_cast(static_cast(p)); + s->descriptorBindingPartiallyBound = VK_TRUE; + s->descriptorBindingSampledImageUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageImageUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageTexelBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingUniformTexelBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingUpdateUnusedWhilePending = VK_TRUE; + s->descriptorBindingVariableDescriptorCount = VK_TRUE; + s->runtimeDescriptorArray = VK_TRUE; + s->shaderSampledImageArrayNonUniformIndexing = VK_TRUE; + s->shaderStorageTexelBufferArrayDynamicIndexing = VK_TRUE; + s->shaderUniformTexelBufferArrayDynamicIndexing = VK_TRUE; + s->shaderUniformTexelBufferArrayNonUniformIndexing = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.depthBiasClamp = VK_TRUE; + s->features.depthClamp = VK_TRUE; + s->features.drawIndirectFirstInstance = VK_TRUE; + s->features.dualSrcBlend = VK_TRUE; + s->features.fillModeNonSolid = VK_TRUE; + s->features.fragmentStoresAndAtomics = VK_TRUE; + s->features.fullDrawIndexUint32 = VK_TRUE; + s->features.imageCubeArray = VK_TRUE; + s->features.independentBlend = VK_TRUE; + s->features.inheritedQueries = VK_TRUE; + s->features.largePoints = VK_TRUE; + s->features.multiDrawIndirect = VK_TRUE; + s->features.multiViewport = VK_TRUE; + s->features.occlusionQueryPrecise = VK_TRUE; + s->features.robustBufferAccess = VK_TRUE; + s->features.sampleRateShading = VK_TRUE; + s->features.samplerAnisotropy = VK_TRUE; + s->features.shaderClipDistance = VK_TRUE; + s->features.shaderImageGatherExtended = VK_TRUE; + s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageBufferArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageExtendedFormats = VK_TRUE; + s->features.shaderStorageImageWriteWithoutFormat = VK_TRUE; + s->features.shaderTessellationAndGeometryPointSize = VK_TRUE; + s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; + s->features.tessellationShader = VK_TRUE; + s->features.textureCompressionBC = VK_TRUE; + s->features.vertexPipelineStoresAndAtomics = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR: + { + VkPhysicalDeviceFloat16Int8FeaturesKHR *s = static_cast(static_cast(p)); + s->shaderInt8 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: + { + VkPhysicalDeviceHostQueryResetFeaturesEXT *s = static_cast(static_cast(p)); + s->hostQueryReset = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: + { + VkPhysicalDeviceInlineUniformBlockFeaturesEXT *s = static_cast(static_cast(p)); + s->descriptorBindingInlineUniformBlockUpdateAfterBind = VK_TRUE; + s->inlineUniformBlock = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: + { + VkPhysicalDeviceMultiviewFeaturesKHR *s = static_cast(static_cast(p)); + s->multiview = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: + { + VkPhysicalDeviceRobustness2FeaturesEXT *s = static_cast(static_cast(p)); + s->robustImageAccess2 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: + { + VkPhysicalDeviceScalarBlockLayoutFeaturesEXT *s = static_cast(static_cast(p)); + s->scalarBlockLayout = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + { + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *s = static_cast(static_cast(p)); + s->texelBufferAlignment = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: + { + VkPhysicalDeviceTimelineSemaphoreFeaturesKHR *s = static_cast(static_cast(p)); + s->timelineSemaphore = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: + { + VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR *s = static_cast(static_cast(p)); + s->uniformBufferStandardLayout = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + { + VkPhysicalDeviceVariablePointersFeaturesKHR *s = static_cast(static_cast(p)); + s->variablePointers = VK_TRUE; + s->variablePointersStorageBuffer = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: + { + VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *s = static_cast(static_cast(p)); + s->vertexAttributeInstanceRateDivisor = VK_TRUE; + s->vertexAttributeInstanceRateZeroDivisor = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR: + { + VkPhysicalDevice16BitStorageFeaturesKHR *prettify_VkPhysicalDevice16BitStorageFeaturesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDevice16BitStorageFeaturesKHR->storageBuffer16BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDevice16BitStorageFeaturesKHR->storageBuffer16BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDevice16BitStorageFeaturesKHR::storageBuffer16BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDevice16BitStorageFeaturesKHR->uniformAndStorageBuffer16BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDevice16BitStorageFeaturesKHR->uniformAndStorageBuffer16BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDevice16BitStorageFeaturesKHR::uniformAndStorageBuffer16BitAccess == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: + { + VkPhysicalDevice8BitStorageFeaturesKHR *prettify_VkPhysicalDevice8BitStorageFeaturesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDevice8BitStorageFeaturesKHR->storageBuffer8BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDevice8BitStorageFeaturesKHR->storageBuffer8BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDevice8BitStorageFeaturesKHR::storageBuffer8BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDevice8BitStorageFeaturesKHR->uniformAndStorageBuffer8BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDevice8BitStorageFeaturesKHR->uniformAndStorageBuffer8BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDevice8BitStorageFeaturesKHR::uniformAndStorageBuffer8BitAccess == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: + { + VkPhysicalDeviceDescriptorIndexingFeaturesEXT *prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingPartiallyBound == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingPartiallyBound == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingPartiallyBound == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingSampledImageUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingStorageImageUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingUpdateUnusedWhilePending == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingUpdateUnusedWhilePending == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingUpdateUnusedWhilePending == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingVariableDescriptorCount == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingVariableDescriptorCount == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingVariableDescriptorCount == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->runtimeDescriptorArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->runtimeDescriptorArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::runtimeDescriptorArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->shaderSampledImageArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->shaderSampledImageArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::shaderSampledImageArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthBiasClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.drawIndirectFirstInstance == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.dualSrcBlend == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.dualSrcBlend == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.dualSrcBlend == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fillModeNonSolid == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fillModeNonSolid == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fillModeNonSolid == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fragmentStoresAndAtomics == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fullDrawIndexUint32 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.imageCubeArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.independentBlend == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.inheritedQueries == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.inheritedQueries == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.inheritedQueries == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.largePoints == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.largePoints == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.largePoints == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.multiDrawIndirect == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.multiDrawIndirect == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.multiDrawIndirect == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.multiViewport == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.multiViewport == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.multiViewport == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.occlusionQueryPrecise == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.occlusionQueryPrecise == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.occlusionQueryPrecise == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.sampleRateShading == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.samplerAnisotropy == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderClipDistance == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderClipDistance == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderClipDistance == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderImageGatherExtended == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderImageGatherExtended == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderImageGatherExtended == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderSampledImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageExtendedFormats == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageWriteWithoutFormat == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageWriteWithoutFormat == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageWriteWithoutFormat == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderTessellationAndGeometryPointSize == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderTessellationAndGeometryPointSize == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderTessellationAndGeometryPointSize == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.tessellationShader == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.tessellationShader == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.tessellationShader == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionBC == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionBC == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.textureCompressionBC == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.vertexPipelineStoresAndAtomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.vertexPipelineStoresAndAtomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.vertexPipelineStoresAndAtomics == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR: + { + VkPhysicalDeviceFloat16Int8FeaturesKHR *prettify_VkPhysicalDeviceFloat16Int8FeaturesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFloat16Int8FeaturesKHR->shaderInt8 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFloat16Int8FeaturesKHR->shaderInt8 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFloat16Int8FeaturesKHR::shaderInt8 == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: + { + VkPhysicalDeviceHostQueryResetFeaturesEXT *prettify_VkPhysicalDeviceHostQueryResetFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceHostQueryResetFeaturesEXT->hostQueryReset == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceHostQueryResetFeaturesEXT->hostQueryReset == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceHostQueryResetFeaturesEXT::hostQueryReset == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: + { + VkPhysicalDeviceInlineUniformBlockFeaturesEXT *prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceInlineUniformBlockFeaturesEXT::descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT->inlineUniformBlock == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT->inlineUniformBlock == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceInlineUniformBlockFeaturesEXT::inlineUniformBlock == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: + { + VkPhysicalDeviceMultiviewFeaturesKHR *prettify_VkPhysicalDeviceMultiviewFeaturesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceMultiviewFeaturesKHR->multiview == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceMultiviewFeaturesKHR->multiview == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceMultiviewFeaturesKHR::multiview == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: + { + VkPhysicalDeviceRobustness2FeaturesEXT *prettify_VkPhysicalDeviceRobustness2FeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceRobustness2FeaturesEXT->robustImageAccess2 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceRobustness2FeaturesEXT->robustImageAccess2 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceRobustness2FeaturesEXT::robustImageAccess2 == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: + { + VkPhysicalDeviceScalarBlockLayoutFeaturesEXT *prettify_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT->scalarBlockLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT->scalarBlockLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceScalarBlockLayoutFeaturesEXT::scalarBlockLayout == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + { + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *prettify_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT->texelBufferAlignment == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT->texelBufferAlignment == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::texelBufferAlignment == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: + { + VkPhysicalDeviceTimelineSemaphoreFeaturesKHR *prettify_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR->timelineSemaphore == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR->timelineSemaphore == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceTimelineSemaphoreFeaturesKHR::timelineSemaphore == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: + { + VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR *prettify_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR->uniformBufferStandardLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR->uniformBufferStandardLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR::uniformBufferStandardLayout == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + { + VkPhysicalDeviceVariablePointersFeaturesKHR *prettify_VkPhysicalDeviceVariablePointersFeaturesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVariablePointersFeaturesKHR->variablePointers == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVariablePointersFeaturesKHR->variablePointers == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVariablePointersFeaturesKHR::variablePointers == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVariablePointersFeaturesKHR->variablePointersStorageBuffer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVariablePointersFeaturesKHR->variablePointersStorageBuffer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVariablePointersFeaturesKHR::variablePointersStorageBuffer == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: + { + VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateDivisor == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateDivisor == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::vertexAttributeInstanceRateDivisor == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateZeroDivisor == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateZeroDivisor == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::vertexAttributeInstanceRateZeroDivisor == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; + [](VkBaseOutStructure *p) { + (void) p; }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } -}; + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceMultiviewFeatures physicalDeviceMultiviewFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, nullptr }; - VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceMultiviewFeatures }; - VkPhysicalDeviceShaderDrawParametersFeatures physicalDeviceShaderDrawParametersFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures }; - VkPhysicalDeviceVariablePointersFeatures physicalDeviceVariablePointersFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, &physicalDeviceShaderDrawParametersFeatures }; - p->pNext = static_cast(static_cast(&physicalDeviceVariablePointersFeatures)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceMultiviewProperties physicalDeviceMultiviewProperties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, nullptr }; - p->pNext = static_cast(static_cast(&physicalDeviceMultiviewProperties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkFormatProperties3KHR formatProperties3KHR{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr }; - p->pNext = static_cast(static_cast(&formatProperties3KHR)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDevice16BitStorageFeaturesKHR physicalDevice16BitStorageFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR, nullptr}; + VkPhysicalDevice8BitStorageFeaturesKHR physicalDevice8BitStorageFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR, &physicalDevice16BitStorageFeaturesKHR}; + VkPhysicalDeviceDescriptorIndexingFeaturesEXT physicalDeviceDescriptorIndexingFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, &physicalDevice8BitStorageFeaturesKHR}; + VkPhysicalDeviceFloat16Int8FeaturesKHR physicalDeviceFloat16Int8FeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR, &physicalDeviceDescriptorIndexingFeaturesEXT}; + VkPhysicalDeviceHostQueryResetFeaturesEXT physicalDeviceHostQueryResetFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT, &physicalDeviceFloat16Int8FeaturesKHR}; + VkPhysicalDeviceInlineUniformBlockFeaturesEXT physicalDeviceInlineUniformBlockFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, &physicalDeviceHostQueryResetFeaturesEXT}; + VkPhysicalDeviceMultiviewFeaturesKHR physicalDeviceMultiviewFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR, &physicalDeviceInlineUniformBlockFeaturesEXT}; + VkPhysicalDeviceRobustness2FeaturesEXT physicalDeviceRobustness2FeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, &physicalDeviceMultiviewFeaturesKHR}; + VkPhysicalDeviceScalarBlockLayoutFeaturesEXT physicalDeviceScalarBlockLayoutFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT, &physicalDeviceRobustness2FeaturesEXT}; + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT physicalDeviceTexelBufferAlignmentFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, &physicalDeviceScalarBlockLayoutFeaturesEXT}; + VkPhysicalDeviceTimelineSemaphoreFeaturesKHR physicalDeviceTimelineSemaphoreFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR, &physicalDeviceTexelBufferAlignmentFeaturesEXT}; + VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR physicalDeviceUniformBufferStandardLayoutFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR, &physicalDeviceTimelineSemaphoreFeaturesKHR}; + VkPhysicalDeviceVariablePointersFeaturesKHR physicalDeviceVariablePointersFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, &physicalDeviceUniformBufferStandardLayoutFeaturesKHR}; + VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT physicalDeviceVertexAttributeDivisorFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, &physicalDeviceVariablePointersFeaturesKHR}; + p->pNext = static_cast(static_cast(&physicalDeviceVertexAttributeDivisorFeaturesEXT)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceDepthStencilResolvePropertiesKHR physicalDeviceDepthStencilResolvePropertiesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR, nullptr}; + VkPhysicalDeviceDescriptorIndexingPropertiesEXT physicalDeviceDescriptorIndexingPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT, &physicalDeviceDepthStencilResolvePropertiesKHR}; + VkPhysicalDeviceInlineUniformBlockPropertiesEXT physicalDeviceInlineUniformBlockPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT, &physicalDeviceDescriptorIndexingPropertiesEXT}; + VkPhysicalDeviceMaintenance3PropertiesKHR physicalDeviceMaintenance3PropertiesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR, &physicalDeviceInlineUniformBlockPropertiesEXT}; + VkPhysicalDeviceMultiviewPropertiesKHR physicalDeviceMultiviewPropertiesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR, &physicalDeviceMaintenance3PropertiesKHR}; + VkPhysicalDeviceRobustness2PropertiesEXT physicalDeviceRobustness2PropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT, &physicalDeviceMultiviewPropertiesKHR}; + VkPhysicalDeviceSubgroupSizeControlPropertiesEXT physicalDeviceSubgroupSizeControlPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT, &physicalDeviceRobustness2PropertiesEXT}; + VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT physicalDeviceTexelBufferAlignmentPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT, &physicalDeviceSubgroupSizeControlPropertiesEXT}; + VkPhysicalDeviceTimelineSemaphorePropertiesKHR physicalDeviceTimelineSemaphorePropertiesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR, &physicalDeviceTexelBufferAlignmentPropertiesEXT}; + VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT physicalDeviceVertexAttributeDivisorPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, &physicalDeviceTimelineSemaphorePropertiesKHR}; + p->pNext = static_cast(static_cast(&physicalDeviceVertexAttributeDivisorPropertiesEXT)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkFormatProperties3KHR formatProperties3KHR{VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr}; + p->pNext = static_cast(static_cast(&formatProperties3KHR)); + pfnCb(p, pUser); }, }; -namespace baseline { -static const VkExtensionProperties instanceExtensions[] = { - VkExtensionProperties{ VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SURFACE_EXTENSION_NAME, 1 }, -}; +namespace blocks +{ +namespace VP_LUNARG_desktop_baseline_2022_block +{ static const VkExtensionProperties deviceExtensions[] = { - VkExtensionProperties{ VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SWAPCHAIN_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, 1 }, + VkExtensionProperties{VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_MEMORY_BUDGET_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_ROBUSTNESS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_KHR_16BIT_STORAGE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_8BIT_STORAGE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_BIND_MEMORY_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DEVICE_GROUP_EXTENSION_NAME, 4}, + VkExtensionProperties{VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_KHR_MAINTENANCE_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_3_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MULTIVIEW_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SWAPCHAIN_EXTENSION_NAME, 70}, + VkExtensionProperties{VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, 1}, }; static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.depthBiasClamp = VK_TRUE; - s->features.fragmentStoresAndAtomics = VK_TRUE; - s->features.fullDrawIndexUint32 = VK_TRUE; - s->features.imageCubeArray = VK_TRUE; - s->features.independentBlend = VK_TRUE; - s->features.largePoints = VK_TRUE; - s->features.robustBufferAccess = VK_TRUE; - s->features.sampleRateShading = VK_TRUE; - s->features.shaderInt16 = VK_TRUE; - s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; - s->features.shaderStorageBufferArrayDynamicIndexing = VK_TRUE; - s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; - s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; - s->features.textureCompressionASTC_LDR = VK_TRUE; - s->features.textureCompressionETC2 = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: { - VkPhysicalDeviceMultiviewFeatures* s = static_cast(static_cast(p)); - s->multiview = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: { - VkPhysicalDeviceSamplerYcbcrConversionFeatures* s = static_cast(static_cast(p)); - s->samplerYcbcrConversion = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: { - VkPhysicalDeviceShaderDrawParametersFeatures* s = static_cast(static_cast(p)); - s->shaderDrawParameters = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: { - VkPhysicalDeviceVariablePointersFeatures* s = static_cast(static_cast(p)); - s->variablePointers = VK_TRUE; - s->variablePointersStorageBuffer = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.depthBiasClamp == VK_TRUE); - ret = ret && (s->features.fragmentStoresAndAtomics == VK_TRUE); - ret = ret && (s->features.fullDrawIndexUint32 == VK_TRUE); - ret = ret && (s->features.imageCubeArray == VK_TRUE); - ret = ret && (s->features.independentBlend == VK_TRUE); - ret = ret && (s->features.largePoints == VK_TRUE); - ret = ret && (s->features.robustBufferAccess == VK_TRUE); - ret = ret && (s->features.sampleRateShading == VK_TRUE); - ret = ret && (s->features.shaderInt16 == VK_TRUE); - ret = ret && (s->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.textureCompressionASTC_LDR == VK_TRUE); - ret = ret && (s->features.textureCompressionETC2 == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: { - VkPhysicalDeviceMultiviewFeatures* s = static_cast(static_cast(p)); - ret = ret && (s->multiview == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: { - VkPhysicalDeviceSamplerYcbcrConversionFeatures* s = static_cast(static_cast(p)); - ret = ret && (s->samplerYcbcrConversion == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: { - VkPhysicalDeviceShaderDrawParametersFeatures* s = static_cast(static_cast(p)); - ret = ret && (s->shaderDrawParameters == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: { - VkPhysicalDeviceVariablePointersFeatures* s = static_cast(static_cast(p)); - ret = ret && (s->variablePointers == VK_TRUE); - ret = ret && (s->variablePointersStorageBuffer == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR: + { + VkPhysicalDevice16BitStorageFeaturesKHR *s = static_cast(static_cast(p)); + s->storageBuffer16BitAccess = VK_TRUE; + s->uniformAndStorageBuffer16BitAccess = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: + { + VkPhysicalDevice8BitStorageFeaturesKHR *s = static_cast(static_cast(p)); + s->storageBuffer8BitAccess = VK_TRUE; + s->uniformAndStorageBuffer8BitAccess = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: + { + VkPhysicalDeviceDescriptorIndexingFeaturesEXT *s = static_cast(static_cast(p)); + s->descriptorBindingPartiallyBound = VK_TRUE; + s->descriptorBindingSampledImageUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageImageUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageTexelBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingUniformTexelBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingUpdateUnusedWhilePending = VK_TRUE; + s->descriptorBindingVariableDescriptorCount = VK_TRUE; + s->runtimeDescriptorArray = VK_TRUE; + s->shaderSampledImageArrayNonUniformIndexing = VK_TRUE; + s->shaderStorageTexelBufferArrayDynamicIndexing = VK_TRUE; + s->shaderUniformTexelBufferArrayDynamicIndexing = VK_TRUE; + s->shaderUniformTexelBufferArrayNonUniformIndexing = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.depthBiasClamp = VK_TRUE; + s->features.depthClamp = VK_TRUE; + s->features.drawIndirectFirstInstance = VK_TRUE; + s->features.dualSrcBlend = VK_TRUE; + s->features.fillModeNonSolid = VK_TRUE; + s->features.fragmentStoresAndAtomics = VK_TRUE; + s->features.fullDrawIndexUint32 = VK_TRUE; + s->features.imageCubeArray = VK_TRUE; + s->features.independentBlend = VK_TRUE; + s->features.inheritedQueries = VK_TRUE; + s->features.largePoints = VK_TRUE; + s->features.multiDrawIndirect = VK_TRUE; + s->features.multiViewport = VK_TRUE; + s->features.occlusionQueryPrecise = VK_TRUE; + s->features.robustBufferAccess = VK_TRUE; + s->features.sampleRateShading = VK_TRUE; + s->features.samplerAnisotropy = VK_TRUE; + s->features.shaderClipDistance = VK_TRUE; + s->features.shaderImageGatherExtended = VK_TRUE; + s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageBufferArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageExtendedFormats = VK_TRUE; + s->features.shaderStorageImageWriteWithoutFormat = VK_TRUE; + s->features.shaderTessellationAndGeometryPointSize = VK_TRUE; + s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; + s->features.tessellationShader = VK_TRUE; + s->features.textureCompressionBC = VK_TRUE; + s->features.vertexPipelineStoresAndAtomics = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR: + { + VkPhysicalDeviceFloat16Int8FeaturesKHR *s = static_cast(static_cast(p)); + s->shaderInt8 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: + { + VkPhysicalDeviceHostQueryResetFeaturesEXT *s = static_cast(static_cast(p)); + s->hostQueryReset = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: + { + VkPhysicalDeviceInlineUniformBlockFeaturesEXT *s = static_cast(static_cast(p)); + s->descriptorBindingInlineUniformBlockUpdateAfterBind = VK_TRUE; + s->inlineUniformBlock = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: + { + VkPhysicalDeviceMultiviewFeaturesKHR *s = static_cast(static_cast(p)); + s->multiview = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: + { + VkPhysicalDeviceRobustness2FeaturesEXT *s = static_cast(static_cast(p)); + s->robustImageAccess2 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: + { + VkPhysicalDeviceScalarBlockLayoutFeaturesEXT *s = static_cast(static_cast(p)); + s->scalarBlockLayout = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + { + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *s = static_cast(static_cast(p)); + s->texelBufferAlignment = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: + { + VkPhysicalDeviceTimelineSemaphoreFeaturesKHR *s = static_cast(static_cast(p)); + s->timelineSemaphore = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: + { + VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR *s = static_cast(static_cast(p)); + s->uniformBufferStandardLayout = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + { + VkPhysicalDeviceVariablePointersFeaturesKHR *s = static_cast(static_cast(p)); + s->variablePointers = VK_TRUE; + s->variablePointersStorageBuffer = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: + { + VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *s = static_cast(static_cast(p)); + s->vertexAttributeInstanceRateDivisor = VK_TRUE; + s->vertexAttributeInstanceRateZeroDivisor = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR: + { + VkPhysicalDevice16BitStorageFeaturesKHR *prettify_VkPhysicalDevice16BitStorageFeaturesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDevice16BitStorageFeaturesKHR->storageBuffer16BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDevice16BitStorageFeaturesKHR->storageBuffer16BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDevice16BitStorageFeaturesKHR::storageBuffer16BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDevice16BitStorageFeaturesKHR->uniformAndStorageBuffer16BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDevice16BitStorageFeaturesKHR->uniformAndStorageBuffer16BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDevice16BitStorageFeaturesKHR::uniformAndStorageBuffer16BitAccess == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: + { + VkPhysicalDevice8BitStorageFeaturesKHR *prettify_VkPhysicalDevice8BitStorageFeaturesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDevice8BitStorageFeaturesKHR->storageBuffer8BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDevice8BitStorageFeaturesKHR->storageBuffer8BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDevice8BitStorageFeaturesKHR::storageBuffer8BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDevice8BitStorageFeaturesKHR->uniformAndStorageBuffer8BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDevice8BitStorageFeaturesKHR->uniformAndStorageBuffer8BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDevice8BitStorageFeaturesKHR::uniformAndStorageBuffer8BitAccess == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: + { + VkPhysicalDeviceDescriptorIndexingFeaturesEXT *prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingPartiallyBound == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingPartiallyBound == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingPartiallyBound == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingSampledImageUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingStorageImageUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingUpdateUnusedWhilePending == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingUpdateUnusedWhilePending == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingUpdateUnusedWhilePending == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingVariableDescriptorCount == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->descriptorBindingVariableDescriptorCount == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::descriptorBindingVariableDescriptorCount == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->runtimeDescriptorArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->runtimeDescriptorArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::runtimeDescriptorArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->shaderSampledImageArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->shaderSampledImageArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::shaderSampledImageArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingFeaturesEXT->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceDescriptorIndexingFeaturesEXT::shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthBiasClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.drawIndirectFirstInstance == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.dualSrcBlend == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.dualSrcBlend == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.dualSrcBlend == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fillModeNonSolid == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fillModeNonSolid == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fillModeNonSolid == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fragmentStoresAndAtomics == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fullDrawIndexUint32 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.imageCubeArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.independentBlend == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.inheritedQueries == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.inheritedQueries == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.inheritedQueries == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.largePoints == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.largePoints == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.largePoints == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.multiDrawIndirect == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.multiDrawIndirect == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.multiDrawIndirect == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.multiViewport == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.multiViewport == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.multiViewport == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.occlusionQueryPrecise == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.occlusionQueryPrecise == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.occlusionQueryPrecise == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.sampleRateShading == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.samplerAnisotropy == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderClipDistance == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderClipDistance == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderClipDistance == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderImageGatherExtended == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderImageGatherExtended == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderImageGatherExtended == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderSampledImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageExtendedFormats == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageWriteWithoutFormat == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageWriteWithoutFormat == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageWriteWithoutFormat == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderTessellationAndGeometryPointSize == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderTessellationAndGeometryPointSize == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderTessellationAndGeometryPointSize == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.tessellationShader == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.tessellationShader == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.tessellationShader == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionBC == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionBC == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.textureCompressionBC == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.vertexPipelineStoresAndAtomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.vertexPipelineStoresAndAtomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.vertexPipelineStoresAndAtomics == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR: + { + VkPhysicalDeviceFloat16Int8FeaturesKHR *prettify_VkPhysicalDeviceFloat16Int8FeaturesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFloat16Int8FeaturesKHR->shaderInt8 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFloat16Int8FeaturesKHR->shaderInt8 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFloat16Int8FeaturesKHR::shaderInt8 == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: + { + VkPhysicalDeviceHostQueryResetFeaturesEXT *prettify_VkPhysicalDeviceHostQueryResetFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceHostQueryResetFeaturesEXT->hostQueryReset == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceHostQueryResetFeaturesEXT->hostQueryReset == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceHostQueryResetFeaturesEXT::hostQueryReset == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: + { + VkPhysicalDeviceInlineUniformBlockFeaturesEXT *prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceInlineUniformBlockFeaturesEXT::descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT->inlineUniformBlock == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT->inlineUniformBlock == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceInlineUniformBlockFeaturesEXT::inlineUniformBlock == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: + { + VkPhysicalDeviceMultiviewFeaturesKHR *prettify_VkPhysicalDeviceMultiviewFeaturesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceMultiviewFeaturesKHR->multiview == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceMultiviewFeaturesKHR->multiview == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceMultiviewFeaturesKHR::multiview == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: + { + VkPhysicalDeviceRobustness2FeaturesEXT *prettify_VkPhysicalDeviceRobustness2FeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceRobustness2FeaturesEXT->robustImageAccess2 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceRobustness2FeaturesEXT->robustImageAccess2 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceRobustness2FeaturesEXT::robustImageAccess2 == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: + { + VkPhysicalDeviceScalarBlockLayoutFeaturesEXT *prettify_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT->scalarBlockLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT->scalarBlockLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceScalarBlockLayoutFeaturesEXT::scalarBlockLayout == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + { + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *prettify_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT->texelBufferAlignment == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT->texelBufferAlignment == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::texelBufferAlignment == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: + { + VkPhysicalDeviceTimelineSemaphoreFeaturesKHR *prettify_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR->timelineSemaphore == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR->timelineSemaphore == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceTimelineSemaphoreFeaturesKHR::timelineSemaphore == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: + { + VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR *prettify_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR->uniformBufferStandardLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR->uniformBufferStandardLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR::uniformBufferStandardLayout == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + { + VkPhysicalDeviceVariablePointersFeaturesKHR *prettify_VkPhysicalDeviceVariablePointersFeaturesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVariablePointersFeaturesKHR->variablePointers == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVariablePointersFeaturesKHR->variablePointers == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVariablePointersFeaturesKHR::variablePointers == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVariablePointersFeaturesKHR->variablePointersStorageBuffer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVariablePointersFeaturesKHR->variablePointersStorageBuffer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVariablePointersFeaturesKHR::variablePointersStorageBuffer == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: + { + VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateDivisor == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateDivisor == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::vertexAttributeInstanceRateDivisor == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateZeroDivisor == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateZeroDivisor == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::vertexAttributeInstanceRateZeroDivisor == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - s->properties.limits.discreteQueuePriorities = 2; - s->properties.limits.framebufferColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.framebufferDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.framebufferNoAttachmentsSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.framebufferStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.maxBoundDescriptorSets = 4; - s->properties.limits.maxColorAttachments = 4; - s->properties.limits.maxComputeSharedMemorySize = 16384; - s->properties.limits.maxComputeWorkGroupCount[0] = 65535; - s->properties.limits.maxComputeWorkGroupCount[1] = 65535; - s->properties.limits.maxComputeWorkGroupCount[2] = 65535; - s->properties.limits.maxComputeWorkGroupInvocations = 128; - s->properties.limits.maxComputeWorkGroupSize[0] = 128; - s->properties.limits.maxComputeWorkGroupSize[1] = 128; - s->properties.limits.maxComputeWorkGroupSize[2] = 64; - s->properties.limits.maxDescriptorSetInputAttachments = 4; - s->properties.limits.maxDescriptorSetSampledImages = 48; - s->properties.limits.maxDescriptorSetSamplers = 48; - s->properties.limits.maxDescriptorSetStorageBuffers = 24; - s->properties.limits.maxDescriptorSetStorageBuffersDynamic = 4; - s->properties.limits.maxDescriptorSetStorageImages = 12; - s->properties.limits.maxDescriptorSetUniformBuffers = 36; - s->properties.limits.maxDescriptorSetUniformBuffersDynamic = 8; - s->properties.limits.maxDrawIndexedIndexValue = 4294967295; - s->properties.limits.maxDrawIndirectCount = 1; - s->properties.limits.maxFragmentCombinedOutputResources = 8; - s->properties.limits.maxFragmentInputComponents = 64; - s->properties.limits.maxFragmentOutputAttachments = 4; - s->properties.limits.maxFramebufferHeight = 4096; - s->properties.limits.maxFramebufferLayers = 256; - s->properties.limits.maxFramebufferWidth = 4096; - s->properties.limits.maxImageArrayLayers = 256; - s->properties.limits.maxImageDimension1D = 4096; - s->properties.limits.maxImageDimension2D = 4096; - s->properties.limits.maxImageDimension3D = 512; - s->properties.limits.maxImageDimensionCube = 4096; - s->properties.limits.maxInterpolationOffset = 0.4375f; - s->properties.limits.maxMemoryAllocationCount = 4096; - s->properties.limits.maxPerStageDescriptorInputAttachments = 4; - s->properties.limits.maxPerStageDescriptorSampledImages = 16; - s->properties.limits.maxPerStageDescriptorSamplers = 16; - s->properties.limits.maxPerStageDescriptorStorageBuffers = 4; - s->properties.limits.maxPerStageDescriptorStorageImages = 4; - s->properties.limits.maxPerStageDescriptorUniformBuffers = 12; - s->properties.limits.maxPerStageResources = 44; - s->properties.limits.maxPushConstantsSize = 128; - s->properties.limits.maxSampleMaskWords = 1; - s->properties.limits.maxSamplerAllocationCount = 4000; - s->properties.limits.maxSamplerAnisotropy = 1.0f; - s->properties.limits.maxSamplerLodBias = 2.0f; - s->properties.limits.maxStorageBufferRange = 134217728; - s->properties.limits.maxTexelBufferElements = 65536; - s->properties.limits.maxTexelOffset = 7; - s->properties.limits.maxUniformBufferRange = 16384; - s->properties.limits.maxVertexInputAttributeOffset = 2047; - s->properties.limits.maxVertexInputAttributes = 16; - s->properties.limits.maxVertexInputBindingStride = 2048; - s->properties.limits.maxVertexInputBindings = 16; - s->properties.limits.maxVertexOutputComponents = 64; - s->properties.limits.maxViewportDimensions[0] = 4096; - s->properties.limits.maxViewportDimensions[1] = 4096; - s->properties.limits.maxViewports = 1; - s->properties.limits.minInterpolationOffset = -0.5f; - s->properties.limits.minStorageBufferOffsetAlignment = 256; - s->properties.limits.minTexelBufferOffsetAlignment = 256; - s->properties.limits.minTexelOffset = -8; - s->properties.limits.minUniformBufferOffsetAlignment = 256; - s->properties.limits.mipmapPrecisionBits = 4; - s->properties.limits.pointSizeGranularity = 1; - s->properties.limits.pointSizeRange[0] = 1.0f; - s->properties.limits.pointSizeRange[1] = 511; - s->properties.limits.sampledImageColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sampledImageDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sampledImageIntegerSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); - s->properties.limits.sampledImageStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.standardSampleLocations = VK_TRUE; - s->properties.limits.storageImageSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); - s->properties.limits.subPixelInterpolationOffsetBits = 4; - s->properties.limits.subPixelPrecisionBits = 4; - s->properties.limits.subTexelPrecisionBits = 4; - s->properties.limits.viewportBoundsRange[0] = -8192; - s->properties.limits.viewportBoundsRange[1] = 8191; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: { - VkPhysicalDeviceMultiviewProperties* s = static_cast(static_cast(p)); - s->maxMultiviewInstanceIndex = 134217727; - s->maxMultiviewViewCount = 6; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->properties.limits.discreteQueuePriorities >= 2); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (s->properties.limits.maxBoundDescriptorSets >= 4); - ret = ret && (s->properties.limits.maxColorAttachments >= 4); - ret = ret && (s->properties.limits.maxComputeSharedMemorySize >= 16384); - ret = ret && (s->properties.limits.maxComputeWorkGroupCount[0] >= 65535); - ret = ret && (s->properties.limits.maxComputeWorkGroupCount[1] >= 65535); - ret = ret && (s->properties.limits.maxComputeWorkGroupCount[2] >= 65535); - ret = ret && (s->properties.limits.maxComputeWorkGroupInvocations >= 128); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[0] >= 128); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[1] >= 128); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[2] >= 64); - ret = ret && (s->properties.limits.maxDescriptorSetInputAttachments >= 4); - ret = ret && (s->properties.limits.maxDescriptorSetSampledImages >= 48); - ret = ret && (s->properties.limits.maxDescriptorSetSamplers >= 48); - ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffers >= 24); - ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4); - ret = ret && (s->properties.limits.maxDescriptorSetStorageImages >= 12); - ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffers >= 36); - ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8); - ret = ret && (s->properties.limits.maxDrawIndexedIndexValue >= 4294967295); - ret = ret && (s->properties.limits.maxDrawIndirectCount >= 1); - ret = ret && (s->properties.limits.maxFragmentCombinedOutputResources >= 8); - ret = ret && (s->properties.limits.maxFragmentInputComponents >= 64); - ret = ret && (s->properties.limits.maxFragmentOutputAttachments >= 4); - ret = ret && (s->properties.limits.maxFramebufferHeight >= 4096); - ret = ret && (s->properties.limits.maxFramebufferLayers >= 256); - ret = ret && (s->properties.limits.maxFramebufferWidth >= 4096); - ret = ret && (s->properties.limits.maxImageArrayLayers >= 256); - ret = ret && (s->properties.limits.maxImageDimension1D >= 4096); - ret = ret && (s->properties.limits.maxImageDimension2D >= 4096); - ret = ret && (s->properties.limits.maxImageDimension3D >= 512); - ret = ret && (s->properties.limits.maxImageDimensionCube >= 4096); - ret = ret && (s->properties.limits.maxInterpolationOffset >= 0.4375); - ret = ret && (s->properties.limits.maxMemoryAllocationCount >= 4096); - ret = ret && (s->properties.limits.maxPerStageDescriptorInputAttachments >= 4); - ret = ret && (s->properties.limits.maxPerStageDescriptorSampledImages >= 16); - ret = ret && (s->properties.limits.maxPerStageDescriptorSamplers >= 16); - ret = ret && (s->properties.limits.maxPerStageDescriptorStorageBuffers >= 4); - ret = ret && (s->properties.limits.maxPerStageDescriptorStorageImages >= 4); - ret = ret && (s->properties.limits.maxPerStageDescriptorUniformBuffers >= 12); - ret = ret && (s->properties.limits.maxPerStageResources >= 44); - ret = ret && (s->properties.limits.maxPushConstantsSize >= 128); - ret = ret && (s->properties.limits.maxSampleMaskWords >= 1); - ret = ret && (s->properties.limits.maxSamplerAllocationCount >= 4000); - ret = ret && (s->properties.limits.maxSamplerAnisotropy >= 1.0); - ret = ret && (s->properties.limits.maxSamplerLodBias >= 2.0); - ret = ret && (s->properties.limits.maxStorageBufferRange >= 134217728); - ret = ret && (s->properties.limits.maxTexelBufferElements >= 65536); - ret = ret && (s->properties.limits.maxTexelOffset >= 7); - ret = ret && (s->properties.limits.maxUniformBufferRange >= 16384); - ret = ret && (s->properties.limits.maxVertexInputAttributeOffset >= 2047); - ret = ret && (s->properties.limits.maxVertexInputAttributes >= 16); - ret = ret && (s->properties.limits.maxVertexInputBindingStride >= 2048); - ret = ret && (s->properties.limits.maxVertexInputBindings >= 16); - ret = ret && (s->properties.limits.maxVertexOutputComponents >= 64); - ret = ret && (s->properties.limits.maxViewportDimensions[0] >= 4096); - ret = ret && (s->properties.limits.maxViewportDimensions[1] >= 4096); - ret = ret && (s->properties.limits.maxViewports >= 1); - ret = ret && (s->properties.limits.minInterpolationOffset <= -0.5); - ret = ret && (s->properties.limits.minStorageBufferOffsetAlignment <= 256); - ret = ret && ((s->properties.limits.minStorageBufferOffsetAlignment & (s->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0); - ret = ret && (s->properties.limits.minTexelBufferOffsetAlignment <= 256); - ret = ret && ((s->properties.limits.minTexelBufferOffsetAlignment & (s->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0); - ret = ret && (s->properties.limits.minTexelOffset <= -8); - ret = ret && (s->properties.limits.minUniformBufferOffsetAlignment <= 256); - ret = ret && ((s->properties.limits.minUniformBufferOffsetAlignment & (s->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0); - ret = ret && (s->properties.limits.mipmapPrecisionBits >= 4); - ret = ret && (s->properties.limits.pointSizeGranularity <= 1); - ret = ret && (isMultiple(1, s->properties.limits.pointSizeGranularity)); - ret = ret && (s->properties.limits.pointSizeRange[0] <= 1.0); - ret = ret && (s->properties.limits.pointSizeRange[1] >= 511); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (s->properties.limits.standardSampleLocations == VK_TRUE); - ret = ret && (vpCheckFlags(s->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); - ret = ret && (s->properties.limits.subPixelInterpolationOffsetBits >= 4); - ret = ret && (s->properties.limits.subPixelPrecisionBits >= 4); - ret = ret && (s->properties.limits.subTexelPrecisionBits >= 4); - ret = ret && (s->properties.limits.viewportBoundsRange[0] <= -8192); - ret = ret && (s->properties.limits.viewportBoundsRange[1] >= 8191); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: { - VkPhysicalDeviceMultiviewProperties* s = static_cast(static_cast(p)); - ret = ret && (s->maxMultiviewInstanceIndex >= 134217727); - ret = ret && (s->maxMultiviewViewCount >= 6); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: + { + VkPhysicalDeviceDepthStencilResolvePropertiesKHR *s = static_cast(static_cast(p)); + s->independentResolve = VK_TRUE; + s->independentResolveNone = VK_TRUE; + s->supportedDepthResolveModes |= (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT); + s->supportedStencilResolveModes |= (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: + { + VkPhysicalDeviceDescriptorIndexingPropertiesEXT *s = static_cast(static_cast(p)); + s->maxDescriptorSetUpdateAfterBindInputAttachments = 256; + s->maxDescriptorSetUpdateAfterBindSampledImages = 640; + s->maxDescriptorSetUpdateAfterBindSamplers = 80; + s->maxDescriptorSetUpdateAfterBindStorageBuffers = 155; + s->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = 8; + s->maxDescriptorSetUpdateAfterBindStorageImages = 40; + s->maxDescriptorSetUpdateAfterBindUniformBuffers = 90; + s->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = 8; + s->maxPerStageDescriptorUpdateAfterBindInputAttachments = 64; + s->maxPerStageDescriptorUpdateAfterBindSampledImages = 128; + s->maxPerStageDescriptorUpdateAfterBindSamplers = 16; + s->maxPerStageDescriptorUpdateAfterBindStorageBuffers = 31; + s->maxPerStageDescriptorUpdateAfterBindStorageImages = 8; + s->maxPerStageDescriptorUpdateAfterBindUniformBuffers = 15; + s->maxPerStageUpdateAfterBindResources = 159; + s->maxUpdateAfterBindDescriptorsInAllPools = 1048576; + s->quadDivergentImplicitLod = VK_FALSE; + s->robustBufferAccessUpdateAfterBind = VK_TRUE; + s->shaderInputAttachmentArrayNonUniformIndexingNative = VK_FALSE; + s->shaderSampledImageArrayNonUniformIndexingNative = VK_FALSE; + s->shaderStorageImageArrayNonUniformIndexingNative = VK_FALSE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: + { + VkPhysicalDeviceInlineUniformBlockPropertiesEXT *s = static_cast(static_cast(p)); + s->maxDescriptorSetInlineUniformBlocks = 4; + s->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = 4; + s->maxInlineUniformBlockSize = 256; + s->maxPerStageDescriptorInlineUniformBlocks = 4; + s->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = 4; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR: + { + VkPhysicalDeviceMaintenance3PropertiesKHR *s = static_cast(static_cast(p)); + s->maxMemoryAllocationSize = 2147483648; + s->maxPerSetDescriptors = 700; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR: + { + VkPhysicalDeviceMultiviewPropertiesKHR *s = static_cast(static_cast(p)); + s->maxMultiviewInstanceIndex = 134217727; + s->maxMultiviewViewCount = 6; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *s = static_cast(static_cast(p)); + s->properties.limits.bufferImageGranularity = 65536; + s->properties.limits.discreteQueuePriorities = 2; + s->properties.limits.framebufferColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferNoAttachmentsSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.lineWidthGranularity = 1.0f; + s->properties.limits.lineWidthRange[0] = 1; + s->properties.limits.lineWidthRange[1] = 1; + s->properties.limits.maxBoundDescriptorSets = 8; + s->properties.limits.maxClipDistances = 8; + s->properties.limits.maxColorAttachments = 8; + s->properties.limits.maxCombinedClipAndCullDistances = 8; + s->properties.limits.maxComputeSharedMemorySize = 32768; + s->properties.limits.maxComputeWorkGroupCount[0] = 65535; + s->properties.limits.maxComputeWorkGroupCount[1] = 65535; + s->properties.limits.maxComputeWorkGroupCount[2] = 65535; + s->properties.limits.maxComputeWorkGroupInvocations = 1024; + s->properties.limits.maxCullDistances = 0; + s->properties.limits.maxDescriptorSetInputAttachments = 7; + s->properties.limits.maxDescriptorSetSampledImages = 640; + s->properties.limits.maxDescriptorSetSamplers = 80; + s->properties.limits.maxDescriptorSetStorageBuffers = 155; + s->properties.limits.maxDescriptorSetStorageBuffersDynamic = 8; + s->properties.limits.maxDescriptorSetStorageImages = 40; + s->properties.limits.maxDescriptorSetUniformBuffers = 90; + s->properties.limits.maxDescriptorSetUniformBuffersDynamic = 8; + s->properties.limits.maxDrawIndexedIndexValue = 4294967294; + s->properties.limits.maxDrawIndirectCount = 1073741824; + s->properties.limits.maxFragmentCombinedOutputResources = 8; + s->properties.limits.maxFragmentDualSrcAttachments = 1; + s->properties.limits.maxFragmentInputComponents = 116; + s->properties.limits.maxFragmentOutputAttachments = 8; + s->properties.limits.maxFramebufferHeight = 16384; + s->properties.limits.maxFramebufferLayers = 1024; + s->properties.limits.maxFramebufferWidth = 16384; + s->properties.limits.maxGeometryInputComponents = 0; + s->properties.limits.maxGeometryOutputComponents = 0; + s->properties.limits.maxGeometryOutputVertices = 0; + s->properties.limits.maxGeometryShaderInvocations = 0; + s->properties.limits.maxGeometryTotalOutputComponents = 0; + s->properties.limits.maxImageArrayLayers = 2048; + s->properties.limits.maxImageDimension1D = 16384; + s->properties.limits.maxImageDimension2D = 16384; + s->properties.limits.maxImageDimension3D = 2048; + s->properties.limits.maxImageDimensionCube = 16384; + s->properties.limits.maxInterpolationOffset = 0.4375f; + s->properties.limits.maxMemoryAllocationCount = 4096; + s->properties.limits.maxPerStageDescriptorInputAttachments = 7; + s->properties.limits.maxPerStageDescriptorSampledImages = 128; + s->properties.limits.maxPerStageDescriptorSamplers = 16; + s->properties.limits.maxPerStageDescriptorStorageBuffers = 31; + s->properties.limits.maxPerStageDescriptorStorageImages = 8; + s->properties.limits.maxPerStageDescriptorUniformBuffers = 15; + s->properties.limits.maxPerStageResources = 159; + s->properties.limits.maxPushConstantsSize = 128; + s->properties.limits.maxSampleMaskWords = 1; + s->properties.limits.maxSamplerAllocationCount = 1024; + s->properties.limits.maxSamplerAnisotropy = 16; + s->properties.limits.maxSamplerLodBias = 0.0f; + s->properties.limits.maxStorageBufferRange = 1073741820; + s->properties.limits.maxTessellationControlPerPatchOutputComponents = 120; + s->properties.limits.maxTessellationControlPerVertexInputComponents = 124; + s->properties.limits.maxTessellationControlPerVertexOutputComponents = 124; + s->properties.limits.maxTessellationControlTotalOutputComponents = 2048; + s->properties.limits.maxTessellationEvaluationInputComponents = 124; + s->properties.limits.maxTessellationEvaluationOutputComponents = 124; + s->properties.limits.maxTessellationGenerationLevel = 64; + s->properties.limits.maxTessellationPatchSize = 32; + s->properties.limits.maxTexelBufferElements = 67108864; + s->properties.limits.maxTexelGatherOffset = 7; + s->properties.limits.maxTexelOffset = 7; + s->properties.limits.maxUniformBufferRange = 65536; + s->properties.limits.maxVertexInputAttributeOffset = 2047; + s->properties.limits.maxVertexInputAttributes = 28; + s->properties.limits.maxVertexInputBindingStride = 2048; + s->properties.limits.maxVertexInputBindings = 28; + s->properties.limits.maxVertexOutputComponents = 124; + s->properties.limits.maxViewportDimensions[0] = 16384; + s->properties.limits.maxViewportDimensions[1] = 16384; + s->properties.limits.maxViewports = 16; + s->properties.limits.minInterpolationOffset = -0.5f; + s->properties.limits.minMemoryMapAlignment = 64; + s->properties.limits.minStorageBufferOffsetAlignment = 64; + s->properties.limits.minTexelBufferOffsetAlignment = 256; + s->properties.limits.minTexelGatherOffset = -8; + s->properties.limits.minTexelOffset = -8; + s->properties.limits.minUniformBufferOffsetAlignment = 256; + s->properties.limits.mipmapPrecisionBits = 4; + s->properties.limits.nonCoherentAtomSize = 256; + s->properties.limits.optimalBufferCopyOffsetAlignment = 256; + s->properties.limits.optimalBufferCopyRowPitchAlignment = 128; + s->properties.limits.pointSizeGranularity = 1; + s->properties.limits.pointSizeRange[0] = 1; + s->properties.limits.pointSizeRange[1] = 64; + s->properties.limits.sampledImageColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageIntegerSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sparseAddressSpaceSize = 0; + s->properties.limits.standardSampleLocations = VK_TRUE; + s->properties.limits.storageImageSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); + s->properties.limits.subPixelInterpolationOffsetBits = 4; + s->properties.limits.subPixelPrecisionBits = 4; + s->properties.limits.subTexelPrecisionBits = 4; + s->properties.limits.timestampComputeAndGraphics = VK_TRUE; + s->properties.limits.viewportBoundsRange[0] = -32768; + s->properties.limits.viewportBoundsRange[1] = 32767; + s->properties.limits.viewportSubPixelBits = 0; + s->properties.sparseProperties.residencyAlignedMipSize = VK_TRUE; + s->properties.sparseProperties.residencyNonResidentStrict = VK_FALSE; + s->properties.sparseProperties.residencyStandard2DBlockShape = VK_FALSE; + s->properties.sparseProperties.residencyStandard2DMultisampleBlockShape = VK_FALSE; + s->properties.sparseProperties.residencyStandard3DBlockShape = VK_FALSE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: + { + VkPhysicalDeviceRobustness2PropertiesEXT *s = static_cast(static_cast(p)); + s->robustStorageBufferAccessSizeAlignment = 4; + s->robustUniformBufferAccessSizeAlignment = 256; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: + { + VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *s = static_cast(static_cast(p)); + s->maxComputeWorkgroupSubgroups = 16; + s->maxSubgroupSize = 1; + s->minSubgroupSize = 64; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: + { + VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *s = static_cast(static_cast(p)); + s->storageTexelBufferOffsetAlignmentBytes = 256; + s->uniformTexelBufferOffsetAlignmentBytes = 256; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR: + { + VkPhysicalDeviceTimelineSemaphorePropertiesKHR *s = static_cast(static_cast(p)); + s->maxTimelineSemaphoreValueDifference = 2147483647; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: + { + VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *s = static_cast(static_cast(p)); + s->maxVertexAttribDivisor = 268435455; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: + { + VkPhysicalDeviceDepthStencilResolvePropertiesKHR *prettify_VkPhysicalDeviceDepthStencilResolvePropertiesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceDepthStencilResolvePropertiesKHR->independentResolve >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDepthStencilResolvePropertiesKHR->independentResolve >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceDepthStencilResolvePropertiesKHR::independentResolve >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDepthStencilResolvePropertiesKHR->independentResolveNone >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDepthStencilResolvePropertiesKHR->independentResolveNone >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceDepthStencilResolvePropertiesKHR::independentResolveNone >= VK_TRUE"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceDepthStencilResolvePropertiesKHR->supportedDepthResolveModes, (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceDepthStencilResolvePropertiesKHR->supportedDepthResolveModes, (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT))), "Unsupported properties condition: VkPhysicalDeviceDepthStencilResolvePropertiesKHR::supportedDepthResolveModes contains (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceDepthStencilResolvePropertiesKHR->supportedStencilResolveModes, (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceDepthStencilResolvePropertiesKHR->supportedStencilResolveModes, (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT))), "Unsupported properties condition: VkPhysicalDeviceDepthStencilResolvePropertiesKHR::supportedStencilResolveModes contains (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT)"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: + { + VkPhysicalDeviceDescriptorIndexingPropertiesEXT *prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxDescriptorSetUpdateAfterBindInputAttachments >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxDescriptorSetUpdateAfterBindInputAttachments >= 256), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindInputAttachments >= 256"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxDescriptorSetUpdateAfterBindSampledImages >= 640); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxDescriptorSetUpdateAfterBindSampledImages >= 640), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindSampledImages >= 640"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxDescriptorSetUpdateAfterBindSamplers >= 80); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxDescriptorSetUpdateAfterBindSamplers >= 80), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindSamplers >= 80"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxDescriptorSetUpdateAfterBindStorageBuffers >= 155); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxDescriptorSetUpdateAfterBindStorageBuffers >= 155), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindStorageBuffers >= 155"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 8), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 8"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxDescriptorSetUpdateAfterBindStorageImages >= 40); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxDescriptorSetUpdateAfterBindStorageImages >= 40), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindStorageImages >= 40"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxDescriptorSetUpdateAfterBindUniformBuffers >= 90); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxDescriptorSetUpdateAfterBindUniformBuffers >= 90), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindUniformBuffers >= 90"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 8), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 8"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxPerStageDescriptorUpdateAfterBindInputAttachments >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxPerStageDescriptorUpdateAfterBindInputAttachments >= 64), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindInputAttachments >= 64"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxPerStageDescriptorUpdateAfterBindSampledImages >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxPerStageDescriptorUpdateAfterBindSampledImages >= 128), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindSampledImages >= 128"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxPerStageDescriptorUpdateAfterBindSamplers >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxPerStageDescriptorUpdateAfterBindSamplers >= 16), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindSamplers >= 16"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 31); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 31), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 31"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxPerStageDescriptorUpdateAfterBindStorageImages >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxPerStageDescriptorUpdateAfterBindStorageImages >= 8), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindStorageImages >= 8"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 15); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 15), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 15"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxPerStageUpdateAfterBindResources >= 159); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxPerStageUpdateAfterBindResources >= 159), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxPerStageUpdateAfterBindResources >= 159"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxUpdateAfterBindDescriptorsInAllPools >= 1048576); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->maxUpdateAfterBindDescriptorsInAllPools >= 1048576), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::maxUpdateAfterBindDescriptorsInAllPools >= 1048576"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->quadDivergentImplicitLod >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->quadDivergentImplicitLod >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::quadDivergentImplicitLod >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->robustBufferAccessUpdateAfterBind >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->robustBufferAccessUpdateAfterBind >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::robustBufferAccessUpdateAfterBind >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->shaderInputAttachmentArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->shaderInputAttachmentArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::shaderInputAttachmentArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->shaderSampledImageArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->shaderSampledImageArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::shaderSampledImageArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->shaderStorageImageArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceDescriptorIndexingPropertiesEXT->shaderStorageImageArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceDescriptorIndexingPropertiesEXT::shaderStorageImageArrayNonUniformIndexingNative >= VK_FALSE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: + { + VkPhysicalDeviceInlineUniformBlockPropertiesEXT *prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxDescriptorSetInlineUniformBlocks >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxDescriptorSetInlineUniformBlocks >= 4), "Unsupported properties condition: VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxDescriptorSetInlineUniformBlocks >= 4"); + ret = ret && (prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxDescriptorSetUpdateAfterBindInlineUniformBlocks >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxDescriptorSetUpdateAfterBindInlineUniformBlocks >= 4), "Unsupported properties condition: VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxDescriptorSetUpdateAfterBindInlineUniformBlocks >= 4"); + ret = ret && (prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxInlineUniformBlockSize >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxInlineUniformBlockSize >= 256), "Unsupported properties condition: VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxInlineUniformBlockSize >= 256"); + ret = ret && (prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxPerStageDescriptorInlineUniformBlocks >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxPerStageDescriptorInlineUniformBlocks >= 4), "Unsupported properties condition: VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxPerStageDescriptorInlineUniformBlocks >= 4"); + ret = ret && (prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks >= 4), "Unsupported properties condition: VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks >= 4"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR: + { + VkPhysicalDeviceMaintenance3PropertiesKHR *prettify_VkPhysicalDeviceMaintenance3PropertiesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceMaintenance3PropertiesKHR->maxMemoryAllocationSize >= 2147483648); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceMaintenance3PropertiesKHR->maxMemoryAllocationSize >= 2147483648), "Unsupported properties condition: VkPhysicalDeviceMaintenance3PropertiesKHR::maxMemoryAllocationSize >= 2147483648"); + ret = ret && (prettify_VkPhysicalDeviceMaintenance3PropertiesKHR->maxPerSetDescriptors >= 700); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceMaintenance3PropertiesKHR->maxPerSetDescriptors >= 700), "Unsupported properties condition: VkPhysicalDeviceMaintenance3PropertiesKHR::maxPerSetDescriptors >= 700"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR: + { + VkPhysicalDeviceMultiviewPropertiesKHR *prettify_VkPhysicalDeviceMultiviewPropertiesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceMultiviewPropertiesKHR->maxMultiviewInstanceIndex >= 134217727); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceMultiviewPropertiesKHR->maxMultiviewInstanceIndex >= 134217727), "Unsupported properties condition: VkPhysicalDeviceMultiviewPropertiesKHR::maxMultiviewInstanceIndex >= 134217727"); + ret = ret && (prettify_VkPhysicalDeviceMultiviewPropertiesKHR->maxMultiviewViewCount >= 6); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceMultiviewPropertiesKHR->maxMultiviewViewCount >= 6), "Unsupported properties condition: VkPhysicalDeviceMultiviewPropertiesKHR::maxMultiviewViewCount >= 6"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *prettify_VkPhysicalDeviceProperties2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity <= 65536); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity <= 65536), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.bufferImageGranularity <= 65536"); + ret = ret && ((65536 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0); + VP_DEBUG_COND_MSG(!((65536 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0), "Unsupported properties condition: (65536 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.discreteQueuePriorities >= 2); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.discreteQueuePriorities >= 2), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.discreteQueuePriorities >= 2"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferDepthSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferNoAttachmentsSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferStencilSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthGranularity <= 1.0"); + ret = ret && (isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)); + VP_DEBUG_COND_MSG(!(isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)), "Unsupported properties condition: isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[0] <= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[0] <= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthRange[0] <= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[1] >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[1] >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthRange[1] >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxBoundDescriptorSets >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxClipDistances >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxClipDistances >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxClipDistances >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxColorAttachments >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCombinedClipAndCullDistances >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCombinedClipAndCullDistances >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxCombinedClipAndCullDistances >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeSharedMemorySize >= 32768); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeSharedMemorySize >= 32768), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeSharedMemorySize >= 32768"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[0] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[0] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[0] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[1] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[1] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[1] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[2] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[2] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[2] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 1024); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 1024), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupInvocations >= 1024"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCullDistances >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCullDistances >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxCullDistances >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetInputAttachments >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetInputAttachments >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetInputAttachments >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 640); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 640), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSampledImages >= 640"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 80); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 80), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSamplers >= 80"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 155); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 155), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffers >= 155"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffersDynamic >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 40); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 40), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageImages >= 40"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 90); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 90), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffers >= 90"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndexedIndexValue >= 4294967294); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndexedIndexValue >= 4294967294), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDrawIndexedIndexValue >= 4294967294"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndirectCount >= 1073741824); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndirectCount >= 1073741824), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDrawIndirectCount >= 1073741824"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentCombinedOutputResources >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentDualSrcAttachments >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentDualSrcAttachments >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentDualSrcAttachments >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentInputComponents >= 116); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentInputComponents >= 116), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentInputComponents >= 116"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentOutputAttachments >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentOutputAttachments >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentOutputAttachments >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferHeight >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferHeight >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferHeight >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferLayers >= 1024); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferLayers >= 1024), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferLayers >= 1024"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferWidth >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferWidth >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferWidth >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryInputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryInputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryInputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputVertices >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputVertices >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryOutputVertices >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryShaderInvocations >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryShaderInvocations >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryShaderInvocations >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryTotalOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryTotalOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryTotalOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageArrayLayers >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension1D >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension2D >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension3D >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension3D >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension3D >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimensionCube >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxInterpolationOffset >= 0.4375); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxInterpolationOffset >= 0.4375), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxInterpolationOffset >= 0.4375"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxMemoryAllocationCount >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxMemoryAllocationCount >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxMemoryAllocationCount >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorInputAttachments >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorInputAttachments >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorInputAttachments >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSampledImages >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSamplers >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 31); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 31), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageBuffers >= 31"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageImages >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 15); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 15), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorUniformBuffers >= 15"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 159); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 159), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageResources >= 159"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPushConstantsSize >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPushConstantsSize >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPushConstantsSize >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSampleMaskWords >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSampleMaskWords >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSampleMaskWords >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAllocationCount >= 1024); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAllocationCount >= 1024), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerAllocationCount >= 1024"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAnisotropy >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAnisotropy >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerAnisotropy >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 0.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 0.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerLodBias >= 0.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxStorageBufferRange >= 1073741820); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxStorageBufferRange >= 1073741820), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxStorageBufferRange >= 1073741820"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerPatchOutputComponents >= 120); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerPatchOutputComponents >= 120), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerPatchOutputComponents >= 120"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexInputComponents >= 124); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexInputComponents >= 124), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerVertexInputComponents >= 124"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexOutputComponents >= 124); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexOutputComponents >= 124), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerVertexOutputComponents >= 124"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlTotalOutputComponents >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlTotalOutputComponents >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlTotalOutputComponents >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationInputComponents >= 124); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationInputComponents >= 124), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationEvaluationInputComponents >= 124"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationOutputComponents >= 124); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationOutputComponents >= 124), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationEvaluationOutputComponents >= 124"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationGenerationLevel >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationGenerationLevel >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationGenerationLevel >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationPatchSize >= 32); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationPatchSize >= 32), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationPatchSize >= 32"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelBufferElements >= 67108864); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelBufferElements >= 67108864), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelBufferElements >= 67108864"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelGatherOffset >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelGatherOffset >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelGatherOffset >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelOffset >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelOffset >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelOffset >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 65536); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 65536), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxUniformBufferRange >= 65536"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributeOffset >= 2047); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributeOffset >= 2047), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputAttributeOffset >= 2047"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributes >= 28); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributes >= 28), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputAttributes >= 28"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindingStride >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindingStride >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputBindingStride >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindings >= 28); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindings >= 28), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputBindings >= 28"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 124); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 124), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexOutputComponents >= 124"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[0] >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[0] >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewportDimensions[0] >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[1] >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[1] >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewportDimensions[1] >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewports >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewports >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewports >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minInterpolationOffset <= -0.5); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minInterpolationOffset <= -0.5), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minInterpolationOffset <= -0.5"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minMemoryMapAlignment >= 64"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment <= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment <= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minStorageBufferOffsetAlignment <= 64"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelGatherOffset <= -8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelGatherOffset <= -8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelGatherOffset <= -8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelOffset <= -8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelOffset <= -8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelOffset <= -8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minUniformBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.mipmapPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.nonCoherentAtomSize <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.optimalBufferCopyOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment <= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment <= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.optimalBufferCopyRowPitchAlignment <= 128"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeGranularity <= 1"); + ret = ret && (isMultiple(1, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)); + VP_DEBUG_COND_MSG(!(isMultiple(1, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)), "Unsupported properties condition: isMultiple(1, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[0] <= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[0] <= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeRange[0] <= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[1] >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[1] >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeRange[1] >= 64"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageDepthSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageIntegerSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageStencilSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sparseAddressSpaceSize >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sparseAddressSpaceSize >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sparseAddressSpaceSize >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.standardSampleLocations >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.standardSampleLocations >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.standardSampleLocations >= VK_TRUE"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.storageImageSampleCounts contains (VK_SAMPLE_COUNT_1_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelInterpolationOffsetBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelInterpolationOffsetBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subPixelInterpolationOffsetBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subPixelPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subTexelPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.timestampComputeAndGraphics >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.timestampComputeAndGraphics >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.timestampComputeAndGraphics >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[0] <= -32768); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[0] <= -32768), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportBoundsRange[0] <= -32768"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[1] >= 32767); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[1] >= 32767), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportBoundsRange[1] >= 32767"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportSubPixelBits >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportSubPixelBits >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportSubPixelBits >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyAlignedMipSize <= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyAlignedMipSize <= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyAlignedMipSize <= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: + { + VkPhysicalDeviceRobustness2PropertiesEXT *prettify_VkPhysicalDeviceRobustness2PropertiesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustStorageBufferAccessSizeAlignment <= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustStorageBufferAccessSizeAlignment <= 4), "Unsupported properties condition: VkPhysicalDeviceRobustness2PropertiesEXT::robustStorageBufferAccessSizeAlignment <= 4"); + ret = ret && ((prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustStorageBufferAccessSizeAlignment & (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustStorageBufferAccessSizeAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustStorageBufferAccessSizeAlignment & (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustStorageBufferAccessSizeAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustStorageBufferAccessSizeAlignment & (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustStorageBufferAccessSizeAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustUniformBufferAccessSizeAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustUniformBufferAccessSizeAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceRobustness2PropertiesEXT::robustUniformBufferAccessSizeAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustUniformBufferAccessSizeAlignment & (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustUniformBufferAccessSizeAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustUniformBufferAccessSizeAlignment & (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustUniformBufferAccessSizeAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustUniformBufferAccessSizeAlignment & (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustUniformBufferAccessSizeAlignment - 1)) == 0"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: + { + VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxComputeWorkgroupSubgroups >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxComputeWorkgroupSubgroups >= 16), "Unsupported properties condition: VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::maxComputeWorkgroupSubgroups >= 16"); + ret = ret && (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxSubgroupSize >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxSubgroupSize >= 1), "Unsupported properties condition: VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::maxSubgroupSize >= 1"); + ret = ret && ((prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxSubgroupSize & (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxSubgroupSize - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxSubgroupSize & (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxSubgroupSize - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxSubgroupSize & (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxSubgroupSize - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->minSubgroupSize <= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->minSubgroupSize <= 64), "Unsupported properties condition: VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::minSubgroupSize <= 64"); + ret = ret && ((prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->minSubgroupSize & (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->minSubgroupSize - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->minSubgroupSize & (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->minSubgroupSize - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->minSubgroupSize & (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->minSubgroupSize - 1)) == 0"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: + { + VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->storageTexelBufferOffsetAlignmentBytes <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->storageTexelBufferOffsetAlignmentBytes <= 256), "Unsupported properties condition: VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::storageTexelBufferOffsetAlignmentBytes <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->storageTexelBufferOffsetAlignmentBytes & (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->storageTexelBufferOffsetAlignmentBytes - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->storageTexelBufferOffsetAlignmentBytes & (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->storageTexelBufferOffsetAlignmentBytes - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->storageTexelBufferOffsetAlignmentBytes & (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->storageTexelBufferOffsetAlignmentBytes - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->uniformTexelBufferOffsetAlignmentBytes <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->uniformTexelBufferOffsetAlignmentBytes <= 256), "Unsupported properties condition: VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::uniformTexelBufferOffsetAlignmentBytes <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->uniformTexelBufferOffsetAlignmentBytes & (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->uniformTexelBufferOffsetAlignmentBytes - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->uniformTexelBufferOffsetAlignmentBytes & (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->uniformTexelBufferOffsetAlignmentBytes - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->uniformTexelBufferOffsetAlignmentBytes & (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->uniformTexelBufferOffsetAlignmentBytes - 1)) == 0"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR: + { + VkPhysicalDeviceTimelineSemaphorePropertiesKHR *prettify_VkPhysicalDeviceTimelineSemaphorePropertiesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceTimelineSemaphorePropertiesKHR->maxTimelineSemaphoreValueDifference >= 2147483647); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceTimelineSemaphorePropertiesKHR->maxTimelineSemaphoreValueDifference >= 2147483647), "Unsupported properties condition: VkPhysicalDeviceTimelineSemaphorePropertiesKHR::maxTimelineSemaphoreValueDifference >= 2147483647"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: + { + VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *prettify_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT->maxVertexAttribDivisor >= 268435455); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT->maxVertexAttribDivisor >= 268435455), "Unsupported properties condition: VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::maxVertexAttribDivisor >= 268435455"); + } + break; + default: + break; + } + return ret; + }}; static const VpFormatDesc formatDesc[] = { - { - VK_FORMAT_A1R5G5B5_UNORM_PACK16, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_A2B10G10R10_UINT_PACK32, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_A2B10G10R10_UNORM_PACK32, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_A8B8G8R8_SINT_PACK32, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_A8B8G8R8_SNORM_PACK32, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_A8B8G8R8_SRGB_PACK32, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_A8B8G8R8_UINT_PACK32, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_A8B8G8R8_UNORM_PACK32, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_10x10_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_10x10_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_10x5_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_10x5_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_10x6_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_10x6_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_10x8_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_10x8_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_12x10_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_12x10_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_12x12_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_12x12_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_4x4_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_4x4_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_5x4_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_5x4_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_5x5_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_5x5_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_6x5_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_6x5_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_6x6_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_6x6_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_8x5_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_8x5_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_8x6_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_8x6_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_8x8_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ASTC_8x8_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_B10G11R11_UFLOAT_PACK32, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_B4G4R4A4_UNORM_PACK16, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_B8G8R8A8_SRGB, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_B8G8R8A8_UNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_D16_UNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_D32_SFLOAT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_EAC_R11G11_SNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_EAC_R11G11_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_EAC_R11_SNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_EAC_R11_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R16G16B16A16_SFLOAT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R16G16B16A16_SINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R16G16B16A16_SNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R16G16B16A16_UINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R16G16_SFLOAT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R16G16_SINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R16G16_SNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R16G16_UINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R16_SFLOAT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R16_SINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R16_SNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R16_UINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R16_UNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R32G32B32A32_SFLOAT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R32G32B32A32_SINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R32G32B32A32_UINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R32G32_SFLOAT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R32G32_SINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R32G32_UINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R32_SFLOAT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R32_SINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R32_UINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R5G6B5_UNORM_PACK16, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R8G8B8A8_SINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R8G8B8A8_SNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R8G8B8A8_SRGB, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R8G8B8A8_UINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R8G8B8A8_UNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R8G8_SINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R8G8_SNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R8G8_UINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R8G8_UNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R8_SINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } - }, - { - VK_FORMAT_R8_SNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + {VK_FORMAT_A2B10G10R10_SNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_SNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A2B10G10R10_UINT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A2B10G10R10_UNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A2R10G10B10_UNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A2R10G10B10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2R10G10B10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2R10G10B10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_SINT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_SNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_SRGB_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SRGB_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SRGB_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_SSCALED_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SSCALED_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_UINT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_UNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_USCALED_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_USCALED_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_B10G11R11_UFLOAT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_B8G8R8A8_SRGB, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_SRGB: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_SRGB: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_B8G8R8A8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC1_RGBA_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC1_RGBA_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC1_RGBA_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC1_RGBA_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC1_RGB_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC1_RGB_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC1_RGB_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC1_RGB_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC2_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC2_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC2_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC2_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC3_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC3_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC3_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC3_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC4_SNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC4_SNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC4_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC4_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC5_SNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC5_SNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC5_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC5_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC6H_SFLOAT_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC6H_SFLOAT_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC6H_UFLOAT_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC6H_UFLOAT_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC7_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC7_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC7_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC7_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_D16_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_D16_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_D32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_D32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_D32_SFLOAT_S8_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_D32_SFLOAT_S8_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32A32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32A32_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32A32_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_SRGB, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SRGB: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SRGB: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, +}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDevice16BitStorageFeaturesKHR physicalDevice16BitStorageFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR, nullptr}; + VkPhysicalDevice8BitStorageFeaturesKHR physicalDevice8BitStorageFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR, &physicalDevice16BitStorageFeaturesKHR}; + VkPhysicalDeviceDescriptorIndexingFeaturesEXT physicalDeviceDescriptorIndexingFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, &physicalDevice8BitStorageFeaturesKHR}; + VkPhysicalDeviceFloat16Int8FeaturesKHR physicalDeviceFloat16Int8FeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR, &physicalDeviceDescriptorIndexingFeaturesEXT}; + VkPhysicalDeviceHostQueryResetFeaturesEXT physicalDeviceHostQueryResetFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT, &physicalDeviceFloat16Int8FeaturesKHR}; + VkPhysicalDeviceInlineUniformBlockFeaturesEXT physicalDeviceInlineUniformBlockFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, &physicalDeviceHostQueryResetFeaturesEXT}; + VkPhysicalDeviceMultiviewFeaturesKHR physicalDeviceMultiviewFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR, &physicalDeviceInlineUniformBlockFeaturesEXT}; + VkPhysicalDeviceRobustness2FeaturesEXT physicalDeviceRobustness2FeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, &physicalDeviceMultiviewFeaturesKHR}; + VkPhysicalDeviceScalarBlockLayoutFeaturesEXT physicalDeviceScalarBlockLayoutFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT, &physicalDeviceRobustness2FeaturesEXT}; + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT physicalDeviceTexelBufferAlignmentFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, &physicalDeviceScalarBlockLayoutFeaturesEXT}; + VkPhysicalDeviceTimelineSemaphoreFeaturesKHR physicalDeviceTimelineSemaphoreFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR, &physicalDeviceTexelBufferAlignmentFeaturesEXT}; + VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR physicalDeviceUniformBufferStandardLayoutFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR, &physicalDeviceTimelineSemaphoreFeaturesKHR}; + VkPhysicalDeviceVariablePointersFeaturesKHR physicalDeviceVariablePointersFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, &physicalDeviceUniformBufferStandardLayoutFeaturesKHR}; + VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT physicalDeviceVertexAttributeDivisorFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, &physicalDeviceVariablePointersFeaturesKHR}; + p->pNext = static_cast(static_cast(&physicalDeviceVertexAttributeDivisorFeaturesEXT)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceDepthStencilResolvePropertiesKHR physicalDeviceDepthStencilResolvePropertiesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR, nullptr}; + VkPhysicalDeviceDescriptorIndexingPropertiesEXT physicalDeviceDescriptorIndexingPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT, &physicalDeviceDepthStencilResolvePropertiesKHR}; + VkPhysicalDeviceInlineUniformBlockPropertiesEXT physicalDeviceInlineUniformBlockPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT, &physicalDeviceDescriptorIndexingPropertiesEXT}; + VkPhysicalDeviceMaintenance3PropertiesKHR physicalDeviceMaintenance3PropertiesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR, &physicalDeviceInlineUniformBlockPropertiesEXT}; + VkPhysicalDeviceMultiviewPropertiesKHR physicalDeviceMultiviewPropertiesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR, &physicalDeviceMaintenance3PropertiesKHR}; + VkPhysicalDeviceRobustness2PropertiesEXT physicalDeviceRobustness2PropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT, &physicalDeviceMultiviewPropertiesKHR}; + VkPhysicalDeviceSubgroupSizeControlPropertiesEXT physicalDeviceSubgroupSizeControlPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT, &physicalDeviceRobustness2PropertiesEXT}; + VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT physicalDeviceTexelBufferAlignmentPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT, &physicalDeviceSubgroupSizeControlPropertiesEXT}; + VkPhysicalDeviceTimelineSemaphorePropertiesKHR physicalDeviceTimelineSemaphorePropertiesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR, &physicalDeviceTexelBufferAlignmentPropertiesEXT}; + VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT physicalDeviceVertexAttributeDivisorPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, &physicalDeviceTimelineSemaphorePropertiesKHR}; + p->pNext = static_cast(static_cast(&physicalDeviceVertexAttributeDivisorPropertiesEXT)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkFormatProperties3KHR formatProperties3KHR{VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr}; + p->pNext = static_cast(static_cast(&formatProperties3KHR)); + pfnCb(p, pUser); }, - { - VK_FORMAT_R8_UINT, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } +}; +} // namespace VP_LUNARG_desktop_baseline_2022_block +} // namespace blocks +} // namespace VP_LUNARG_DESKTOP_BASELINE_2022 +#endif // VP_LUNARG_desktop_baseline_2022 + +#ifdef VP_LUNARG_desktop_baseline_2023 +namespace VP_LUNARG_DESKTOP_BASELINE_2023 +{ + +static const VkStructureType featureStructTypes[] = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, +}; + +static const VkStructureType propertyStructTypes[] = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, +}; + +static const VkStructureType formatStructTypes[] = { + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, +}; + +static const VkExtensionProperties deviceExtensions[] = { + VkExtensionProperties{VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_MEMORY_BUDGET_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_ROBUSTNESS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_KHR_16BIT_STORAGE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_8BIT_STORAGE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_BIND_MEMORY_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DEVICE_GROUP_EXTENSION_NAME, 4}, + VkExtensionProperties{VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_KHR_MAINTENANCE_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_3_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MULTIVIEW_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME, 4}, + VkExtensionProperties{VK_KHR_SPIRV_1_4_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SWAPCHAIN_EXTENSION_NAME, 70}, + VkExtensionProperties{VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, 1}, +}; + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.depthBiasClamp = VK_TRUE; + s->features.depthClamp = VK_TRUE; + s->features.drawIndirectFirstInstance = VK_TRUE; + s->features.dualSrcBlend = VK_TRUE; + s->features.fillModeNonSolid = VK_TRUE; + s->features.fragmentStoresAndAtomics = VK_TRUE; + s->features.fullDrawIndexUint32 = VK_TRUE; + s->features.imageCubeArray = VK_TRUE; + s->features.independentBlend = VK_TRUE; + s->features.inheritedQueries = VK_TRUE; + s->features.largePoints = VK_TRUE; + s->features.multiDrawIndirect = VK_TRUE; + s->features.multiViewport = VK_TRUE; + s->features.occlusionQueryPrecise = VK_TRUE; + s->features.robustBufferAccess = VK_TRUE; + s->features.sampleRateShading = VK_TRUE; + s->features.samplerAnisotropy = VK_TRUE; + s->features.shaderClipDistance = VK_TRUE; + s->features.shaderImageGatherExtended = VK_TRUE; + s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageBufferArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageExtendedFormats = VK_TRUE; + s->features.shaderStorageImageWriteWithoutFormat = VK_TRUE; + s->features.shaderTessellationAndGeometryPointSize = VK_TRUE; + s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; + s->features.tessellationShader = VK_TRUE; + s->features.textureCompressionBC = VK_TRUE; + s->features.vertexPipelineStoresAndAtomics = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: + { + VkPhysicalDeviceImageRobustnessFeaturesEXT *s = static_cast(static_cast(p)); + s->robustImageAccess = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: + { + VkPhysicalDeviceInlineUniformBlockFeaturesEXT *s = static_cast(static_cast(p)); + s->descriptorBindingInlineUniformBlockUpdateAfterBind = VK_TRUE; + s->inlineUniformBlock = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: + { + VkPhysicalDeviceRobustness2FeaturesEXT *s = static_cast(static_cast(p)); + s->robustImageAccess2 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + { + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *s = static_cast(static_cast(p)); + s->texelBufferAlignment = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: + { + VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *s = static_cast(static_cast(p)); + s->vertexAttributeInstanceRateDivisor = VK_TRUE; + s->vertexAttributeInstanceRateZeroDivisor = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *s = static_cast(static_cast(p)); + s->multiview = VK_TRUE; + s->protectedMemory = VK_FALSE; + s->shaderDrawParameters = VK_TRUE; + s->storageBuffer16BitAccess = VK_TRUE; + s->uniformAndStorageBuffer16BitAccess = VK_TRUE; + s->variablePointers = VK_TRUE; + s->variablePointersStorageBuffer = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *s = static_cast(static_cast(p)); + s->descriptorBindingPartiallyBound = VK_TRUE; + s->descriptorBindingSampledImageUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageImageUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageTexelBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingUniformTexelBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingUpdateUnusedWhilePending = VK_TRUE; + s->descriptorBindingVariableDescriptorCount = VK_TRUE; + s->descriptorIndexing = VK_TRUE; + s->hostQueryReset = VK_TRUE; + s->imagelessFramebuffer = VK_TRUE; + s->runtimeDescriptorArray = VK_TRUE; + s->samplerMirrorClampToEdge = VK_TRUE; + s->separateDepthStencilLayouts = VK_TRUE; + s->shaderInt8 = VK_TRUE; + s->shaderSampledImageArrayNonUniformIndexing = VK_TRUE; + s->shaderStorageTexelBufferArrayDynamicIndexing = VK_TRUE; + s->shaderUniformTexelBufferArrayDynamicIndexing = VK_TRUE; + s->shaderUniformTexelBufferArrayNonUniformIndexing = VK_TRUE; + s->storageBuffer8BitAccess = VK_TRUE; + s->timelineSemaphore = VK_TRUE; + s->uniformAndStorageBuffer8BitAccess = VK_TRUE; + s->uniformBufferStandardLayout = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthBiasClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.drawIndirectFirstInstance == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.dualSrcBlend == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.dualSrcBlend == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.dualSrcBlend == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fillModeNonSolid == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fillModeNonSolid == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fillModeNonSolid == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fragmentStoresAndAtomics == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fullDrawIndexUint32 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.imageCubeArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.independentBlend == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.inheritedQueries == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.inheritedQueries == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.inheritedQueries == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.largePoints == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.largePoints == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.largePoints == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.multiDrawIndirect == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.multiDrawIndirect == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.multiDrawIndirect == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.multiViewport == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.multiViewport == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.multiViewport == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.occlusionQueryPrecise == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.occlusionQueryPrecise == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.occlusionQueryPrecise == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.sampleRateShading == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.samplerAnisotropy == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderClipDistance == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderClipDistance == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderClipDistance == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderImageGatherExtended == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderImageGatherExtended == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderImageGatherExtended == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderSampledImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageExtendedFormats == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageWriteWithoutFormat == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageWriteWithoutFormat == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageWriteWithoutFormat == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderTessellationAndGeometryPointSize == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderTessellationAndGeometryPointSize == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderTessellationAndGeometryPointSize == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.tessellationShader == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.tessellationShader == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.tessellationShader == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionBC == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionBC == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.textureCompressionBC == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.vertexPipelineStoresAndAtomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.vertexPipelineStoresAndAtomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.vertexPipelineStoresAndAtomics == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: + { + VkPhysicalDeviceImageRobustnessFeaturesEXT *prettify_VkPhysicalDeviceImageRobustnessFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceImageRobustnessFeaturesEXT->robustImageAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceImageRobustnessFeaturesEXT->robustImageAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceImageRobustnessFeaturesEXT::robustImageAccess == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: + { + VkPhysicalDeviceInlineUniformBlockFeaturesEXT *prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceInlineUniformBlockFeaturesEXT::descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT->inlineUniformBlock == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT->inlineUniformBlock == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceInlineUniformBlockFeaturesEXT::inlineUniformBlock == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: + { + VkPhysicalDeviceRobustness2FeaturesEXT *prettify_VkPhysicalDeviceRobustness2FeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceRobustness2FeaturesEXT->robustImageAccess2 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceRobustness2FeaturesEXT->robustImageAccess2 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceRobustness2FeaturesEXT::robustImageAccess2 == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + { + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *prettify_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT->texelBufferAlignment == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT->texelBufferAlignment == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::texelBufferAlignment == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: + { + VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateDivisor == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateDivisor == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::vertexAttributeInstanceRateDivisor == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateZeroDivisor == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateZeroDivisor == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::vertexAttributeInstanceRateZeroDivisor == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *prettify_VkPhysicalDeviceVulkan11Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::multiview == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->protectedMemory == VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->protectedMemory == VK_FALSE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::protectedMemory == VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->shaderDrawParameters == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->shaderDrawParameters == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::shaderDrawParameters == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->storageBuffer16BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->storageBuffer16BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::storageBuffer16BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->uniformAndStorageBuffer16BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->uniformAndStorageBuffer16BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::uniformAndStorageBuffer16BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->variablePointers == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->variablePointers == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::variablePointers == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->variablePointersStorageBuffer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->variablePointersStorageBuffer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::variablePointersStorageBuffer == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *prettify_VkPhysicalDeviceVulkan12Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingPartiallyBound == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingPartiallyBound == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingPartiallyBound == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingSampledImageUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageImageUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUpdateUnusedWhilePending == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUpdateUnusedWhilePending == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingUpdateUnusedWhilePending == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingVariableDescriptorCount == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingVariableDescriptorCount == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingVariableDescriptorCount == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::hostQueryReset == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::imagelessFramebuffer == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->runtimeDescriptorArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->runtimeDescriptorArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::runtimeDescriptorArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->samplerMirrorClampToEdge == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->samplerMirrorClampToEdge == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::samplerMirrorClampToEdge == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::separateDepthStencilLayouts == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderInt8 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderInt8 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderInt8 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderSampledImageArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderSampledImageArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderSampledImageArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->storageBuffer8BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->storageBuffer8BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::storageBuffer8BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::timelineSemaphore == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->uniformAndStorageBuffer8BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->uniformAndStorageBuffer8BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::uniformAndStorageBuffer8BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::uniformBufferStandardLayout == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; }, - { - VK_FORMAT_R8_UNORM, - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); - s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: { - VkFormatProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceImageRobustnessFeaturesEXT physicalDeviceImageRobustnessFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT, nullptr}; + VkPhysicalDeviceInlineUniformBlockFeaturesEXT physicalDeviceInlineUniformBlockFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, &physicalDeviceImageRobustnessFeaturesEXT}; + VkPhysicalDeviceRobustness2FeaturesEXT physicalDeviceRobustness2FeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, &physicalDeviceInlineUniformBlockFeaturesEXT}; + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT physicalDeviceTexelBufferAlignmentFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, &physicalDeviceRobustness2FeaturesEXT}; + VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT physicalDeviceVertexAttributeDivisorFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, &physicalDeviceTexelBufferAlignmentFeaturesEXT}; + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, &physicalDeviceVertexAttributeDivisorFeaturesEXT}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Features)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkFormatProperties3KHR formatProperties3KHR{VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr}; + p->pNext = static_cast(static_cast(&formatProperties3KHR)); + pfnCb(p, pUser); }, }; +namespace blocks +{ +namespace VP_LUNARG_desktop_baseline_2023_block +{ + +static const VkExtensionProperties deviceExtensions[] = { + VkExtensionProperties{VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_MEMORY_BUDGET_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_ROBUSTNESS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_KHR_16BIT_STORAGE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_8BIT_STORAGE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_BIND_MEMORY_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DEVICE_GROUP_EXTENSION_NAME, 4}, + VkExtensionProperties{VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_KHR_MAINTENANCE_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_3_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MULTIVIEW_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME, 4}, + VkExtensionProperties{VK_KHR_SPIRV_1_4_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SWAPCHAIN_EXTENSION_NAME, 70}, + VkExtensionProperties{VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, 1}, +}; + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.depthBiasClamp = VK_TRUE; + s->features.depthClamp = VK_TRUE; + s->features.drawIndirectFirstInstance = VK_TRUE; + s->features.dualSrcBlend = VK_TRUE; + s->features.fillModeNonSolid = VK_TRUE; + s->features.fragmentStoresAndAtomics = VK_TRUE; + s->features.fullDrawIndexUint32 = VK_TRUE; + s->features.imageCubeArray = VK_TRUE; + s->features.independentBlend = VK_TRUE; + s->features.inheritedQueries = VK_TRUE; + s->features.largePoints = VK_TRUE; + s->features.multiDrawIndirect = VK_TRUE; + s->features.multiViewport = VK_TRUE; + s->features.occlusionQueryPrecise = VK_TRUE; + s->features.robustBufferAccess = VK_TRUE; + s->features.sampleRateShading = VK_TRUE; + s->features.samplerAnisotropy = VK_TRUE; + s->features.shaderClipDistance = VK_TRUE; + s->features.shaderImageGatherExtended = VK_TRUE; + s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageBufferArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageExtendedFormats = VK_TRUE; + s->features.shaderStorageImageWriteWithoutFormat = VK_TRUE; + s->features.shaderTessellationAndGeometryPointSize = VK_TRUE; + s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; + s->features.tessellationShader = VK_TRUE; + s->features.textureCompressionBC = VK_TRUE; + s->features.vertexPipelineStoresAndAtomics = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: + { + VkPhysicalDeviceImageRobustnessFeaturesEXT *s = static_cast(static_cast(p)); + s->robustImageAccess = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: + { + VkPhysicalDeviceInlineUniformBlockFeaturesEXT *s = static_cast(static_cast(p)); + s->descriptorBindingInlineUniformBlockUpdateAfterBind = VK_TRUE; + s->inlineUniformBlock = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: + { + VkPhysicalDeviceRobustness2FeaturesEXT *s = static_cast(static_cast(p)); + s->robustImageAccess2 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + { + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *s = static_cast(static_cast(p)); + s->texelBufferAlignment = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: + { + VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *s = static_cast(static_cast(p)); + s->vertexAttributeInstanceRateDivisor = VK_TRUE; + s->vertexAttributeInstanceRateZeroDivisor = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *s = static_cast(static_cast(p)); + s->multiview = VK_TRUE; + s->protectedMemory = VK_FALSE; + s->shaderDrawParameters = VK_TRUE; + s->storageBuffer16BitAccess = VK_TRUE; + s->uniformAndStorageBuffer16BitAccess = VK_TRUE; + s->variablePointers = VK_TRUE; + s->variablePointersStorageBuffer = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *s = static_cast(static_cast(p)); + s->descriptorBindingPartiallyBound = VK_TRUE; + s->descriptorBindingSampledImageUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageImageUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageTexelBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingUniformTexelBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingUpdateUnusedWhilePending = VK_TRUE; + s->descriptorBindingVariableDescriptorCount = VK_TRUE; + s->descriptorIndexing = VK_TRUE; + s->hostQueryReset = VK_TRUE; + s->imagelessFramebuffer = VK_TRUE; + s->runtimeDescriptorArray = VK_TRUE; + s->samplerMirrorClampToEdge = VK_TRUE; + s->separateDepthStencilLayouts = VK_TRUE; + s->shaderInt8 = VK_TRUE; + s->shaderSampledImageArrayNonUniformIndexing = VK_TRUE; + s->shaderStorageTexelBufferArrayDynamicIndexing = VK_TRUE; + s->shaderUniformTexelBufferArrayDynamicIndexing = VK_TRUE; + s->shaderUniformTexelBufferArrayNonUniformIndexing = VK_TRUE; + s->storageBuffer8BitAccess = VK_TRUE; + s->timelineSemaphore = VK_TRUE; + s->uniformAndStorageBuffer8BitAccess = VK_TRUE; + s->uniformBufferStandardLayout = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthBiasClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.drawIndirectFirstInstance == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.dualSrcBlend == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.dualSrcBlend == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.dualSrcBlend == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fillModeNonSolid == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fillModeNonSolid == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fillModeNonSolid == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fragmentStoresAndAtomics == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fullDrawIndexUint32 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.imageCubeArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.independentBlend == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.inheritedQueries == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.inheritedQueries == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.inheritedQueries == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.largePoints == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.largePoints == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.largePoints == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.multiDrawIndirect == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.multiDrawIndirect == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.multiDrawIndirect == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.multiViewport == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.multiViewport == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.multiViewport == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.occlusionQueryPrecise == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.occlusionQueryPrecise == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.occlusionQueryPrecise == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.sampleRateShading == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.samplerAnisotropy == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderClipDistance == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderClipDistance == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderClipDistance == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderImageGatherExtended == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderImageGatherExtended == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderImageGatherExtended == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderSampledImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageExtendedFormats == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageWriteWithoutFormat == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageWriteWithoutFormat == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageWriteWithoutFormat == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderTessellationAndGeometryPointSize == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderTessellationAndGeometryPointSize == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderTessellationAndGeometryPointSize == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.tessellationShader == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.tessellationShader == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.tessellationShader == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionBC == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionBC == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.textureCompressionBC == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.vertexPipelineStoresAndAtomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.vertexPipelineStoresAndAtomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.vertexPipelineStoresAndAtomics == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: + { + VkPhysicalDeviceImageRobustnessFeaturesEXT *prettify_VkPhysicalDeviceImageRobustnessFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceImageRobustnessFeaturesEXT->robustImageAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceImageRobustnessFeaturesEXT->robustImageAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceImageRobustnessFeaturesEXT::robustImageAccess == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: + { + VkPhysicalDeviceInlineUniformBlockFeaturesEXT *prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceInlineUniformBlockFeaturesEXT::descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT->inlineUniformBlock == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceInlineUniformBlockFeaturesEXT->inlineUniformBlock == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceInlineUniformBlockFeaturesEXT::inlineUniformBlock == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: + { + VkPhysicalDeviceRobustness2FeaturesEXT *prettify_VkPhysicalDeviceRobustness2FeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceRobustness2FeaturesEXT->robustImageAccess2 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceRobustness2FeaturesEXT->robustImageAccess2 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceRobustness2FeaturesEXT::robustImageAccess2 == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + { + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *prettify_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT->texelBufferAlignment == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT->texelBufferAlignment == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::texelBufferAlignment == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: + { + VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateDivisor == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateDivisor == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::vertexAttributeInstanceRateDivisor == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateZeroDivisor == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateZeroDivisor == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::vertexAttributeInstanceRateZeroDivisor == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *prettify_VkPhysicalDeviceVulkan11Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::multiview == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->protectedMemory == VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->protectedMemory == VK_FALSE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::protectedMemory == VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->shaderDrawParameters == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->shaderDrawParameters == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::shaderDrawParameters == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->storageBuffer16BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->storageBuffer16BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::storageBuffer16BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->uniformAndStorageBuffer16BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->uniformAndStorageBuffer16BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::uniformAndStorageBuffer16BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->variablePointers == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->variablePointers == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::variablePointers == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->variablePointersStorageBuffer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->variablePointersStorageBuffer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::variablePointersStorageBuffer == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *prettify_VkPhysicalDeviceVulkan12Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingPartiallyBound == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingPartiallyBound == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingPartiallyBound == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingSampledImageUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageImageUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUpdateUnusedWhilePending == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUpdateUnusedWhilePending == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingUpdateUnusedWhilePending == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingVariableDescriptorCount == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingVariableDescriptorCount == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingVariableDescriptorCount == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::hostQueryReset == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::imagelessFramebuffer == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->runtimeDescriptorArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->runtimeDescriptorArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::runtimeDescriptorArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->samplerMirrorClampToEdge == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->samplerMirrorClampToEdge == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::samplerMirrorClampToEdge == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::separateDepthStencilLayouts == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderInt8 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderInt8 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderInt8 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderSampledImageArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderSampledImageArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderSampledImageArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->storageBuffer8BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->storageBuffer8BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::storageBuffer8BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::timelineSemaphore == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->uniformAndStorageBuffer8BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->uniformAndStorageBuffer8BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::uniformAndStorageBuffer8BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::uniformBufferStandardLayout == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *s = static_cast(static_cast(p)); + s->properties.limits.bufferImageGranularity = 65536; + s->properties.limits.discreteQueuePriorities = 2; + s->properties.limits.framebufferColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferNoAttachmentsSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.lineWidthGranularity = 1.0f; + s->properties.limits.lineWidthRange[0] = 1; + s->properties.limits.lineWidthRange[1] = 1; + s->properties.limits.maxBoundDescriptorSets = 8; + s->properties.limits.maxClipDistances = 8; + s->properties.limits.maxColorAttachments = 8; + s->properties.limits.maxCombinedClipAndCullDistances = 8; + s->properties.limits.maxComputeSharedMemorySize = 32768; + s->properties.limits.maxComputeWorkGroupCount[0] = 65535; + s->properties.limits.maxComputeWorkGroupCount[1] = 65535; + s->properties.limits.maxComputeWorkGroupCount[2] = 65535; + s->properties.limits.maxComputeWorkGroupInvocations = 1024; + s->properties.limits.maxComputeWorkGroupSize[0] = 1024; + s->properties.limits.maxComputeWorkGroupSize[1] = 1024; + s->properties.limits.maxComputeWorkGroupSize[2] = 64; + s->properties.limits.maxCullDistances = 0; + s->properties.limits.maxDescriptorSetInputAttachments = 7; + s->properties.limits.maxDescriptorSetSampledImages = 640; + s->properties.limits.maxDescriptorSetSamplers = 80; + s->properties.limits.maxDescriptorSetStorageBuffers = 155; + s->properties.limits.maxDescriptorSetStorageBuffersDynamic = 8; + s->properties.limits.maxDescriptorSetStorageImages = 40; + s->properties.limits.maxDescriptorSetUniformBuffers = 90; + s->properties.limits.maxDescriptorSetUniformBuffersDynamic = 8; + s->properties.limits.maxDrawIndexedIndexValue = 4294967295; + s->properties.limits.maxDrawIndirectCount = 1073741824; + s->properties.limits.maxFragmentCombinedOutputResources = 8; + s->properties.limits.maxFragmentDualSrcAttachments = 1; + s->properties.limits.maxFragmentInputComponents = 116; + s->properties.limits.maxFragmentOutputAttachments = 8; + s->properties.limits.maxFramebufferHeight = 16384; + s->properties.limits.maxFramebufferLayers = 1024; + s->properties.limits.maxFramebufferWidth = 16384; + s->properties.limits.maxGeometryInputComponents = 0; + s->properties.limits.maxGeometryOutputComponents = 0; + s->properties.limits.maxGeometryOutputVertices = 0; + s->properties.limits.maxGeometryShaderInvocations = 0; + s->properties.limits.maxGeometryTotalOutputComponents = 0; + s->properties.limits.maxImageArrayLayers = 2048; + s->properties.limits.maxImageDimension1D = 16384; + s->properties.limits.maxImageDimension2D = 16384; + s->properties.limits.maxImageDimension3D = 2048; + s->properties.limits.maxImageDimensionCube = 16384; + s->properties.limits.maxInterpolationOffset = 0.4375f; + s->properties.limits.maxMemoryAllocationCount = 4096; + s->properties.limits.maxPerStageDescriptorInputAttachments = 7; + s->properties.limits.maxPerStageDescriptorSampledImages = 128; + s->properties.limits.maxPerStageDescriptorSamplers = 16; + s->properties.limits.maxPerStageDescriptorStorageBuffers = 31; + s->properties.limits.maxPerStageDescriptorStorageImages = 8; + s->properties.limits.maxPerStageDescriptorUniformBuffers = 15; + s->properties.limits.maxPerStageResources = 159; + s->properties.limits.maxPushConstantsSize = 128; + s->properties.limits.maxSampleMaskWords = 1; + s->properties.limits.maxSamplerAllocationCount = 4000; + s->properties.limits.maxSamplerAnisotropy = 16; + s->properties.limits.maxSamplerLodBias = 4; + s->properties.limits.maxStorageBufferRange = 1073741820; + s->properties.limits.maxTessellationControlPerPatchOutputComponents = 120; + s->properties.limits.maxTessellationControlPerVertexInputComponents = 124; + s->properties.limits.maxTessellationControlPerVertexOutputComponents = 124; + s->properties.limits.maxTessellationControlTotalOutputComponents = 2048; + s->properties.limits.maxTessellationEvaluationInputComponents = 124; + s->properties.limits.maxTessellationEvaluationOutputComponents = 124; + s->properties.limits.maxTessellationGenerationLevel = 64; + s->properties.limits.maxTessellationPatchSize = 32; + s->properties.limits.maxTexelBufferElements = 67108864; + s->properties.limits.maxTexelGatherOffset = 7; + s->properties.limits.maxTexelOffset = 7; + s->properties.limits.maxUniformBufferRange = 65536; + s->properties.limits.maxVertexInputAttributeOffset = 2047; + s->properties.limits.maxVertexInputAttributes = 28; + s->properties.limits.maxVertexInputBindingStride = 2048; + s->properties.limits.maxVertexInputBindings = 28; + s->properties.limits.maxVertexOutputComponents = 124; + s->properties.limits.maxViewportDimensions[0] = 16384; + s->properties.limits.maxViewportDimensions[1] = 16384; + s->properties.limits.maxViewports = 16; + s->properties.limits.minInterpolationOffset = -0.5f; + s->properties.limits.minMemoryMapAlignment = 64; + s->properties.limits.minStorageBufferOffsetAlignment = 64; + s->properties.limits.minTexelBufferOffsetAlignment = 256; + s->properties.limits.minTexelGatherOffset = -8; + s->properties.limits.minTexelOffset = -8; + s->properties.limits.minUniformBufferOffsetAlignment = 256; + s->properties.limits.mipmapPrecisionBits = 4; + s->properties.limits.nonCoherentAtomSize = 256; + s->properties.limits.optimalBufferCopyOffsetAlignment = 256; + s->properties.limits.optimalBufferCopyRowPitchAlignment = 128; + s->properties.limits.pointSizeGranularity = 1; + s->properties.limits.pointSizeRange[0] = 1; + s->properties.limits.pointSizeRange[1] = 64; + s->properties.limits.sampledImageColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageIntegerSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sparseAddressSpaceSize = 0; + s->properties.limits.standardSampleLocations = VK_TRUE; + s->properties.limits.storageImageSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); + s->properties.limits.strictLines = VK_FALSE; + s->properties.limits.subPixelInterpolationOffsetBits = 4; + s->properties.limits.subPixelPrecisionBits = 4; + s->properties.limits.subTexelPrecisionBits = 4; + s->properties.limits.timestampComputeAndGraphics = VK_TRUE; + s->properties.limits.viewportBoundsRange[0] = -32768; + s->properties.limits.viewportBoundsRange[1] = 32767; + s->properties.limits.viewportSubPixelBits = 0; + s->properties.sparseProperties.residencyAlignedMipSize = VK_TRUE; + s->properties.sparseProperties.residencyNonResidentStrict = VK_FALSE; + s->properties.sparseProperties.residencyStandard2DBlockShape = VK_FALSE; + s->properties.sparseProperties.residencyStandard2DMultisampleBlockShape = VK_FALSE; + s->properties.sparseProperties.residencyStandard3DBlockShape = VK_FALSE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + { + VkPhysicalDeviceVulkan11Properties *s = static_cast(static_cast(p)); + s->maxMemoryAllocationSize = 1610612736; + s->maxMultiviewInstanceIndex = 134217727; + s->maxMultiviewViewCount = 6; + s->maxPerSetDescriptors = 700; + s->subgroupQuadOperationsInAllStages = VK_FALSE; + s->subgroupSize = 1; + s->subgroupSupportedOperations |= (VK_SUBGROUP_FEATURE_BASIC_BIT); + s->subgroupSupportedStages |= (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + { + VkPhysicalDeviceVulkan12Properties *s = static_cast(static_cast(p)); + s->filterMinmaxImageComponentMapping = VK_FALSE; + s->filterMinmaxSingleComponentFormats = VK_FALSE; + s->framebufferIntegerColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); + s->independentResolve = VK_TRUE; + s->independentResolveNone = VK_TRUE; + s->maxDescriptorSetUpdateAfterBindInputAttachments = 256; + s->maxDescriptorSetUpdateAfterBindSampledImages = 640; + s->maxDescriptorSetUpdateAfterBindSamplers = 80; + s->maxDescriptorSetUpdateAfterBindStorageBuffers = 155; + s->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = 8; + s->maxDescriptorSetUpdateAfterBindStorageImages = 40; + s->maxDescriptorSetUpdateAfterBindUniformBuffers = 90; + s->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = 8; + s->maxPerStageDescriptorUpdateAfterBindInputAttachments = 64; + s->maxPerStageDescriptorUpdateAfterBindSampledImages = 128; + s->maxPerStageDescriptorUpdateAfterBindSamplers = 16; + s->maxPerStageDescriptorUpdateAfterBindStorageBuffers = 31; + s->maxPerStageDescriptorUpdateAfterBindStorageImages = 8; + s->maxPerStageDescriptorUpdateAfterBindUniformBuffers = 15; + s->maxPerStageUpdateAfterBindResources = 159; + s->maxTimelineSemaphoreValueDifference = 0; + s->maxUpdateAfterBindDescriptorsInAllPools = 1048576; + s->quadDivergentImplicitLod = VK_FALSE; + s->robustBufferAccessUpdateAfterBind = VK_FALSE; + s->shaderDenormFlushToZeroFloat16 = VK_FALSE; + s->shaderDenormFlushToZeroFloat32 = VK_FALSE; + s->shaderDenormFlushToZeroFloat64 = VK_FALSE; + s->shaderDenormPreserveFloat16 = VK_FALSE; + s->shaderDenormPreserveFloat32 = VK_FALSE; + s->shaderDenormPreserveFloat64 = VK_FALSE; + s->shaderInputAttachmentArrayNonUniformIndexingNative = VK_FALSE; + s->shaderRoundingModeRTEFloat16 = VK_FALSE; + s->shaderRoundingModeRTEFloat32 = VK_FALSE; + s->shaderRoundingModeRTEFloat64 = VK_FALSE; + s->shaderRoundingModeRTZFloat16 = VK_FALSE; + s->shaderRoundingModeRTZFloat32 = VK_FALSE; + s->shaderRoundingModeRTZFloat64 = VK_FALSE; + s->shaderSampledImageArrayNonUniformIndexingNative = VK_FALSE; + s->shaderSignedZeroInfNanPreserveFloat16 = VK_FALSE; + s->shaderSignedZeroInfNanPreserveFloat32 = VK_TRUE; + s->shaderSignedZeroInfNanPreserveFloat64 = VK_FALSE; + s->shaderStorageBufferArrayNonUniformIndexingNative = VK_FALSE; + s->shaderStorageImageArrayNonUniformIndexingNative = VK_FALSE; + s->shaderUniformBufferArrayNonUniformIndexingNative = VK_FALSE; + s->supportedDepthResolveModes |= (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT); + s->supportedStencilResolveModes |= (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *prettify_VkPhysicalDeviceProperties2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity <= 65536); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity <= 65536), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.bufferImageGranularity <= 65536"); + ret = ret && ((65536 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0); + VP_DEBUG_COND_MSG(!((65536 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0), "Unsupported properties condition: (65536 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.discreteQueuePriorities >= 2); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.discreteQueuePriorities >= 2), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.discreteQueuePriorities >= 2"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferDepthSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferNoAttachmentsSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferStencilSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthGranularity <= 1.0"); + ret = ret && (isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)); + VP_DEBUG_COND_MSG(!(isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)), "Unsupported properties condition: isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[0] <= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[0] <= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthRange[0] <= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[1] >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[1] >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthRange[1] >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxBoundDescriptorSets >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxClipDistances >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxClipDistances >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxClipDistances >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxColorAttachments >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCombinedClipAndCullDistances >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCombinedClipAndCullDistances >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxCombinedClipAndCullDistances >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeSharedMemorySize >= 32768); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeSharedMemorySize >= 32768), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeSharedMemorySize >= 32768"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[0] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[0] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[0] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[1] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[1] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[1] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[2] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[2] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[2] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 1024); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 1024), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupInvocations >= 1024"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 1024); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 1024), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[0] >= 1024"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 1024); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 1024), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[1] >= 1024"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[2] >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCullDistances >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCullDistances >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxCullDistances >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetInputAttachments >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetInputAttachments >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetInputAttachments >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 640); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 640), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSampledImages >= 640"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 80); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 80), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSamplers >= 80"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 155); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 155), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffers >= 155"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffersDynamic >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 40); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 40), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageImages >= 40"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 90); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 90), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffers >= 90"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndexedIndexValue >= 4294967295); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndexedIndexValue >= 4294967295), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDrawIndexedIndexValue >= 4294967295"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndirectCount >= 1073741824); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndirectCount >= 1073741824), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDrawIndirectCount >= 1073741824"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentCombinedOutputResources >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentDualSrcAttachments >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentDualSrcAttachments >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentDualSrcAttachments >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentInputComponents >= 116); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentInputComponents >= 116), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentInputComponents >= 116"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentOutputAttachments >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentOutputAttachments >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentOutputAttachments >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferHeight >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferHeight >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferHeight >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferLayers >= 1024); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferLayers >= 1024), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferLayers >= 1024"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferWidth >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferWidth >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferWidth >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryInputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryInputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryInputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputVertices >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputVertices >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryOutputVertices >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryShaderInvocations >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryShaderInvocations >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryShaderInvocations >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryTotalOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryTotalOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryTotalOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageArrayLayers >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension1D >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension2D >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension3D >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension3D >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension3D >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimensionCube >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxInterpolationOffset >= 0.4375); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxInterpolationOffset >= 0.4375), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxInterpolationOffset >= 0.4375"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxMemoryAllocationCount >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxMemoryAllocationCount >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxMemoryAllocationCount >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorInputAttachments >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorInputAttachments >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorInputAttachments >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSampledImages >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSamplers >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 31); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 31), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageBuffers >= 31"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageImages >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 15); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 15), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorUniformBuffers >= 15"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 159); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 159), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageResources >= 159"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPushConstantsSize >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPushConstantsSize >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPushConstantsSize >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSampleMaskWords >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSampleMaskWords >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSampleMaskWords >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAllocationCount >= 4000); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAllocationCount >= 4000), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerAllocationCount >= 4000"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAnisotropy >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAnisotropy >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerAnisotropy >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerLodBias >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxStorageBufferRange >= 1073741820); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxStorageBufferRange >= 1073741820), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxStorageBufferRange >= 1073741820"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerPatchOutputComponents >= 120); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerPatchOutputComponents >= 120), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerPatchOutputComponents >= 120"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexInputComponents >= 124); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexInputComponents >= 124), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerVertexInputComponents >= 124"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexOutputComponents >= 124); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexOutputComponents >= 124), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerVertexOutputComponents >= 124"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlTotalOutputComponents >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlTotalOutputComponents >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlTotalOutputComponents >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationInputComponents >= 124); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationInputComponents >= 124), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationEvaluationInputComponents >= 124"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationOutputComponents >= 124); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationOutputComponents >= 124), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationEvaluationOutputComponents >= 124"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationGenerationLevel >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationGenerationLevel >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationGenerationLevel >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationPatchSize >= 32); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationPatchSize >= 32), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationPatchSize >= 32"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelBufferElements >= 67108864); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelBufferElements >= 67108864), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelBufferElements >= 67108864"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelGatherOffset >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelGatherOffset >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelGatherOffset >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelOffset >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelOffset >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelOffset >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 65536); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 65536), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxUniformBufferRange >= 65536"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributeOffset >= 2047); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributeOffset >= 2047), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputAttributeOffset >= 2047"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributes >= 28); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributes >= 28), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputAttributes >= 28"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindingStride >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindingStride >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputBindingStride >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindings >= 28); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindings >= 28), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputBindings >= 28"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 124); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 124), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexOutputComponents >= 124"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[0] >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[0] >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewportDimensions[0] >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[1] >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[1] >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewportDimensions[1] >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewports >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewports >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewports >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minInterpolationOffset <= -0.5); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minInterpolationOffset <= -0.5), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minInterpolationOffset <= -0.5"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minMemoryMapAlignment >= 64"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment <= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment <= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minStorageBufferOffsetAlignment <= 64"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelGatherOffset <= -8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelGatherOffset <= -8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelGatherOffset <= -8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelOffset <= -8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelOffset <= -8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelOffset <= -8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minUniformBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.mipmapPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.nonCoherentAtomSize <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.optimalBufferCopyOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment <= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment <= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.optimalBufferCopyRowPitchAlignment <= 128"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeGranularity <= 1"); + ret = ret && (isMultiple(1, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)); + VP_DEBUG_COND_MSG(!(isMultiple(1, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)), "Unsupported properties condition: isMultiple(1, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[0] <= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[0] <= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeRange[0] <= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[1] >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[1] >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeRange[1] >= 64"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageDepthSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageIntegerSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageStencilSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sparseAddressSpaceSize >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sparseAddressSpaceSize >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sparseAddressSpaceSize >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.standardSampleLocations >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.standardSampleLocations >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.standardSampleLocations >= VK_TRUE"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.storageImageSampleCounts contains (VK_SAMPLE_COUNT_1_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.strictLines >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.strictLines >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.strictLines >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelInterpolationOffsetBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelInterpolationOffsetBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subPixelInterpolationOffsetBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subPixelPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subTexelPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.timestampComputeAndGraphics >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.timestampComputeAndGraphics >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.timestampComputeAndGraphics >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[0] <= -32768); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[0] <= -32768), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportBoundsRange[0] <= -32768"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[1] >= 32767); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[1] >= 32767), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportBoundsRange[1] >= 32767"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportSubPixelBits >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportSubPixelBits >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportSubPixelBits >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyAlignedMipSize <= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyAlignedMipSize <= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyAlignedMipSize <= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + { + VkPhysicalDeviceVulkan11Properties *prettify_VkPhysicalDeviceVulkan11Properties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->maxMemoryAllocationSize >= 1610612736); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->maxMemoryAllocationSize >= 1610612736), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::maxMemoryAllocationSize >= 1610612736"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewInstanceIndex >= 134217727); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewInstanceIndex >= 134217727), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::maxMultiviewInstanceIndex >= 134217727"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewViewCount >= 6); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewViewCount >= 6), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::maxMultiviewViewCount >= 6"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->maxPerSetDescriptors >= 700); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->maxPerSetDescriptors >= 700), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::maxPerSetDescriptors >= 700"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->subgroupQuadOperationsInAllStages >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->subgroupQuadOperationsInAllStages >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::subgroupQuadOperationsInAllStages >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize >= 1), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::subgroupSize >= 1"); + ret = ret && ((prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize & (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize & (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize & (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize - 1)) == 0"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::subgroupSupportedOperations contains (VK_SUBGROUP_FEATURE_BASIC_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedStages, (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedStages, (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::subgroupSupportedStages contains (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT)"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + { + VkPhysicalDeviceVulkan12Properties *prettify_VkPhysicalDeviceVulkan12Properties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->filterMinmaxImageComponentMapping >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->filterMinmaxImageComponentMapping >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::filterMinmaxImageComponentMapping >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->filterMinmaxSingleComponentFormats >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->filterMinmaxSingleComponentFormats >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::filterMinmaxSingleComponentFormats >= VK_FALSE"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan12Properties->framebufferIntegerColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan12Properties->framebufferIntegerColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::framebufferIntegerColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->independentResolve >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->independentResolve >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::independentResolve >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->independentResolveNone >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->independentResolveNone >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::independentResolveNone >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindInputAttachments >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindInputAttachments >= 256), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindInputAttachments >= 256"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSampledImages >= 640); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSampledImages >= 640), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindSampledImages >= 640"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSamplers >= 80); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSamplers >= 80), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindSamplers >= 80"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffers >= 155); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffers >= 155), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindStorageBuffers >= 155"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 8), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 8"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageImages >= 40); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageImages >= 40), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindStorageImages >= 40"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffers >= 90); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffers >= 90), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindUniformBuffers >= 90"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 8), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 8"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindInputAttachments >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindInputAttachments >= 64), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindInputAttachments >= 64"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSampledImages >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSampledImages >= 128), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindSampledImages >= 128"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSamplers >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSamplers >= 16), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindSamplers >= 16"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 31); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 31), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 31"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageImages >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageImages >= 8), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindStorageImages >= 8"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 15); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 15), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 15"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageUpdateAfterBindResources >= 159); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageUpdateAfterBindResources >= 159), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageUpdateAfterBindResources >= 159"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxTimelineSemaphoreValueDifference >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxTimelineSemaphoreValueDifference >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxTimelineSemaphoreValueDifference >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxUpdateAfterBindDescriptorsInAllPools >= 1048576); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxUpdateAfterBindDescriptorsInAllPools >= 1048576), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxUpdateAfterBindDescriptorsInAllPools >= 1048576"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->quadDivergentImplicitLod >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->quadDivergentImplicitLod >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::quadDivergentImplicitLod >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->robustBufferAccessUpdateAfterBind >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->robustBufferAccessUpdateAfterBind >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::robustBufferAccessUpdateAfterBind >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormFlushToZeroFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormFlushToZeroFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormFlushToZeroFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormPreserveFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormPreserveFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormPreserveFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderInputAttachmentArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderInputAttachmentArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderInputAttachmentArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTEFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTEFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTEFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTZFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTZFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTZFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderSampledImageArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderSampledImageArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderSampledImageArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderSignedZeroInfNanPreserveFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat32 >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat32 >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderSignedZeroInfNanPreserveFloat32 >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderSignedZeroInfNanPreserveFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderStorageBufferArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderStorageBufferArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderStorageBufferArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderStorageImageArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderStorageImageArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderStorageImageArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderUniformBufferArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderUniformBufferArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderUniformBufferArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan12Properties->supportedDepthResolveModes, (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan12Properties->supportedDepthResolveModes, (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::supportedDepthResolveModes contains (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan12Properties->supportedStencilResolveModes, (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan12Properties->supportedStencilResolveModes, (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::supportedStencilResolveModes contains (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT)"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpFormatDesc formatDesc[] = { + {VK_FORMAT_A2B10G10R10_SNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_SNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A2B10G10R10_UINT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A2B10G10R10_UNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A2R10G10B10_UNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A2R10G10B10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2R10G10B10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2R10G10B10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_SINT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_SNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_SRGB_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SRGB_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SRGB_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_SSCALED_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SSCALED_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_UINT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_UNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_USCALED_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_USCALED_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_B10G11R11_UFLOAT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_B8G8R8A8_SRGB, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_SRGB: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_SRGB: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_B8G8R8A8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC1_RGBA_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC1_RGBA_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC1_RGBA_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC1_RGBA_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC1_RGB_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC1_RGB_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC1_RGB_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC1_RGB_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC2_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC2_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC2_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC2_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC3_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC3_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC3_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC3_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC4_SNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC4_SNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC4_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC4_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC5_SNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC5_SNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC5_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC5_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC6H_SFLOAT_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC6H_SFLOAT_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC6H_UFLOAT_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC6H_UFLOAT_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC7_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC7_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC7_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC7_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_D16_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_D16_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_D32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_D32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_D32_SFLOAT_S8_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_D32_SFLOAT_S8_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32A32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32A32_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32A32_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_SRGB, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SRGB: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SRGB: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, +}; + static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceMultiviewFeatures physicalDeviceMultiviewFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, nullptr }; - VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceMultiviewFeatures }; - VkPhysicalDeviceShaderDrawParametersFeatures physicalDeviceShaderDrawParametersFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures }; - VkPhysicalDeviceVariablePointersFeatures physicalDeviceVariablePointersFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, &physicalDeviceShaderDrawParametersFeatures }; - p->pNext = static_cast(static_cast(&physicalDeviceVariablePointersFeatures)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceMultiviewProperties physicalDeviceMultiviewProperties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, nullptr }; - p->pNext = static_cast(static_cast(&physicalDeviceMultiviewProperties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkFormatProperties3KHR formatProperties3KHR{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr }; - p->pNext = static_cast(static_cast(&formatProperties3KHR)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceImageRobustnessFeaturesEXT physicalDeviceImageRobustnessFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT, nullptr}; + VkPhysicalDeviceInlineUniformBlockFeaturesEXT physicalDeviceInlineUniformBlockFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, &physicalDeviceImageRobustnessFeaturesEXT}; + VkPhysicalDeviceRobustness2FeaturesEXT physicalDeviceRobustness2FeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, &physicalDeviceInlineUniformBlockFeaturesEXT}; + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT physicalDeviceTexelBufferAlignmentFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, &physicalDeviceRobustness2FeaturesEXT}; + VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT physicalDeviceVertexAttributeDivisorFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, &physicalDeviceTexelBufferAlignmentFeaturesEXT}; + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, &physicalDeviceVertexAttributeDivisorFeaturesEXT}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Features)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkFormatProperties3KHR formatProperties3KHR{VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr}; + p->pNext = static_cast(static_cast(&formatProperties3KHR)); + pfnCb(p, pUser); }, }; -} //namespace baseline -} // namespace VP_ANDROID_BASELINE_2022 -#endif // VP_ANDROID_baseline_2022 +} // namespace VP_LUNARG_desktop_baseline_2023_block +} // namespace blocks +} // namespace VP_LUNARG_DESKTOP_BASELINE_2023 +#endif // VP_LUNARG_desktop_baseline_2023 -#ifdef VP_KHR_roadmap_2022 -namespace VP_KHR_ROADMAP_2022 { +#ifdef VP_LUNARG_desktop_baseline_2024 +namespace VP_LUNARG_DESKTOP_BASELINE_2024 +{ static const VkStructureType featureStructTypes[] = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, }; static const VkStructureType propertyStructTypes[] = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, +}; + +static const VkStructureType formatStructTypes[] = { + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, }; static const VkExtensionProperties deviceExtensions[] = { - VkExtensionProperties{ VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME, 1 }, + VkExtensionProperties{VK_EXT_4444_FORMATS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_MEMORY_BUDGET_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_PRIVATE_DATA_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_ROBUSTNESS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_KHR_16BIT_STORAGE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_8BIT_STORAGE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_BIND_MEMORY_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DEVICE_GROUP_EXTENSION_NAME, 4}, + VkExtensionProperties{VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_KHR_MAINTENANCE_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_3_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MULTIVIEW_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME, 4}, + VkExtensionProperties{VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SPIRV_1_4_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SWAPCHAIN_EXTENSION_NAME, 70}, + VkExtensionProperties{VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, 1}, }; static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.depthBiasClamp = VK_TRUE; - s->features.depthClamp = VK_TRUE; - s->features.drawIndirectFirstInstance = VK_TRUE; - s->features.fragmentStoresAndAtomics = VK_TRUE; - s->features.fullDrawIndexUint32 = VK_TRUE; - s->features.imageCubeArray = VK_TRUE; - s->features.independentBlend = VK_TRUE; - s->features.occlusionQueryPrecise = VK_TRUE; - s->features.robustBufferAccess = VK_TRUE; - s->features.sampleRateShading = VK_TRUE; - s->features.samplerAnisotropy = VK_TRUE; - s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; - s->features.shaderStorageBufferArrayDynamicIndexing = VK_TRUE; - s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; - s->features.shaderStorageImageExtendedFormats = VK_TRUE; - s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceVulkan11Features* s = static_cast(static_cast(p)); - s->multiview = VK_TRUE; - s->samplerYcbcrConversion = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - s->bufferDeviceAddress = VK_TRUE; - s->descriptorBindingPartiallyBound = VK_TRUE; - s->descriptorBindingSampledImageUpdateAfterBind = VK_TRUE; - s->descriptorBindingStorageBufferUpdateAfterBind = VK_TRUE; - s->descriptorBindingStorageImageUpdateAfterBind = VK_TRUE; - s->descriptorBindingStorageTexelBufferUpdateAfterBind = VK_TRUE; - s->descriptorBindingUniformTexelBufferUpdateAfterBind = VK_TRUE; - s->descriptorBindingUpdateUnusedWhilePending = VK_TRUE; - s->descriptorBindingVariableDescriptorCount = VK_TRUE; - s->descriptorIndexing = VK_TRUE; - s->hostQueryReset = VK_TRUE; - s->imagelessFramebuffer = VK_TRUE; - s->runtimeDescriptorArray = VK_TRUE; - s->samplerMirrorClampToEdge = VK_TRUE; - s->scalarBlockLayout = VK_TRUE; - s->separateDepthStencilLayouts = VK_TRUE; - s->shaderSampledImageArrayNonUniformIndexing = VK_TRUE; - s->shaderStorageBufferArrayNonUniformIndexing = VK_TRUE; - s->shaderStorageImageArrayNonUniformIndexing = VK_TRUE; - s->shaderStorageTexelBufferArrayDynamicIndexing = VK_TRUE; - s->shaderStorageTexelBufferArrayNonUniformIndexing = VK_TRUE; - s->shaderSubgroupExtendedTypes = VK_TRUE; - s->shaderUniformBufferArrayNonUniformIndexing = VK_TRUE; - s->shaderUniformTexelBufferArrayDynamicIndexing = VK_TRUE; - s->shaderUniformTexelBufferArrayNonUniformIndexing = VK_TRUE; - s->subgroupBroadcastDynamicId = VK_TRUE; - s->timelineSemaphore = VK_TRUE; - s->uniformBufferStandardLayout = VK_TRUE; - s->vulkanMemoryModel = VK_TRUE; - s->vulkanMemoryModelDeviceScope = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: { - VkPhysicalDeviceVulkan13Features* s = static_cast(static_cast(p)); - s->computeFullSubgroups = VK_TRUE; - s->descriptorBindingInlineUniformBlockUpdateAfterBind = VK_TRUE; - s->dynamicRendering = VK_TRUE; - s->inlineUniformBlock = VK_TRUE; - s->maintenance4 = VK_TRUE; - s->pipelineCreationCacheControl = VK_TRUE; - s->robustImageAccess = VK_TRUE; - s->shaderDemoteToHelperInvocation = VK_TRUE; - s->shaderIntegerDotProduct = VK_TRUE; - s->shaderTerminateInvocation = VK_TRUE; - s->shaderZeroInitializeWorkgroupMemory = VK_TRUE; - s->subgroupSizeControl = VK_TRUE; - s->synchronization2 = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.depthBiasClamp == VK_TRUE); - ret = ret && (s->features.depthClamp == VK_TRUE); - ret = ret && (s->features.drawIndirectFirstInstance == VK_TRUE); - ret = ret && (s->features.fragmentStoresAndAtomics == VK_TRUE); - ret = ret && (s->features.fullDrawIndexUint32 == VK_TRUE); - ret = ret && (s->features.imageCubeArray == VK_TRUE); - ret = ret && (s->features.independentBlend == VK_TRUE); - ret = ret && (s->features.occlusionQueryPrecise == VK_TRUE); - ret = ret && (s->features.robustBufferAccess == VK_TRUE); - ret = ret && (s->features.sampleRateShading == VK_TRUE); - ret = ret && (s->features.samplerAnisotropy == VK_TRUE); - ret = ret && (s->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.shaderStorageImageExtendedFormats == VK_TRUE); - ret = ret && (s->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceVulkan11Features* s = static_cast(static_cast(p)); - ret = ret && (s->multiview == VK_TRUE); - ret = ret && (s->samplerYcbcrConversion == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - ret = ret && (s->bufferDeviceAddress == VK_TRUE); - ret = ret && (s->descriptorBindingPartiallyBound == VK_TRUE); - ret = ret && (s->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE); - ret = ret && (s->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE); - ret = ret && (s->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE); - ret = ret && (s->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE); - ret = ret && (s->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE); - ret = ret && (s->descriptorBindingUpdateUnusedWhilePending == VK_TRUE); - ret = ret && (s->descriptorBindingVariableDescriptorCount == VK_TRUE); - ret = ret && (s->descriptorIndexing == VK_TRUE); - ret = ret && (s->hostQueryReset == VK_TRUE); - ret = ret && (s->imagelessFramebuffer == VK_TRUE); - ret = ret && (s->runtimeDescriptorArray == VK_TRUE); - ret = ret && (s->samplerMirrorClampToEdge == VK_TRUE); - ret = ret && (s->scalarBlockLayout == VK_TRUE); - ret = ret && (s->separateDepthStencilLayouts == VK_TRUE); - ret = ret && (s->shaderSampledImageArrayNonUniformIndexing == VK_TRUE); - ret = ret && (s->shaderStorageBufferArrayNonUniformIndexing == VK_TRUE); - ret = ret && (s->shaderStorageImageArrayNonUniformIndexing == VK_TRUE); - ret = ret && (s->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE); - ret = ret && (s->shaderSubgroupExtendedTypes == VK_TRUE); - ret = ret && (s->shaderUniformBufferArrayNonUniformIndexing == VK_TRUE); - ret = ret && (s->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE); - ret = ret && (s->subgroupBroadcastDynamicId == VK_TRUE); - ret = ret && (s->timelineSemaphore == VK_TRUE); - ret = ret && (s->uniformBufferStandardLayout == VK_TRUE); - ret = ret && (s->vulkanMemoryModel == VK_TRUE); - ret = ret && (s->vulkanMemoryModelDeviceScope == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: { - VkPhysicalDeviceVulkan13Features* s = static_cast(static_cast(p)); - ret = ret && (s->computeFullSubgroups == VK_TRUE); - ret = ret && (s->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE); - ret = ret && (s->dynamicRendering == VK_TRUE); - ret = ret && (s->inlineUniformBlock == VK_TRUE); - ret = ret && (s->maintenance4 == VK_TRUE); - ret = ret && (s->pipelineCreationCacheControl == VK_TRUE); - ret = ret && (s->robustImageAccess == VK_TRUE); - ret = ret && (s->shaderDemoteToHelperInvocation == VK_TRUE); - ret = ret && (s->shaderIntegerDotProduct == VK_TRUE); - ret = ret && (s->shaderTerminateInvocation == VK_TRUE); - ret = ret && (s->shaderZeroInitializeWorkgroupMemory == VK_TRUE); - ret = ret && (s->subgroupSizeControl == VK_TRUE); - ret = ret && (s->synchronization2 == VK_TRUE); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + { + VkPhysicalDevice4444FormatsFeaturesEXT *s = static_cast(static_cast(p)); + s->formatA4R4G4B4 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + { + VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *s = static_cast(static_cast(p)); + s->extendedDynamicState2 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + { + VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *s = static_cast(static_cast(p)); + s->extendedDynamicState = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.depthBiasClamp = VK_TRUE; + s->features.depthClamp = VK_TRUE; + s->features.drawIndirectFirstInstance = VK_TRUE; + s->features.dualSrcBlend = VK_TRUE; + s->features.fillModeNonSolid = VK_TRUE; + s->features.fragmentStoresAndAtomics = VK_TRUE; + s->features.fullDrawIndexUint32 = VK_TRUE; + s->features.imageCubeArray = VK_TRUE; + s->features.independentBlend = VK_TRUE; + s->features.inheritedQueries = VK_TRUE; + s->features.largePoints = VK_TRUE; + s->features.multiDrawIndirect = VK_TRUE; + s->features.multiViewport = VK_TRUE; + s->features.occlusionQueryPrecise = VK_TRUE; + s->features.robustBufferAccess = VK_TRUE; + s->features.sampleRateShading = VK_TRUE; + s->features.samplerAnisotropy = VK_TRUE; + s->features.shaderClipDistance = VK_TRUE; + s->features.shaderImageGatherExtended = VK_TRUE; + s->features.shaderInt16 = VK_TRUE; + s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageBufferArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageExtendedFormats = VK_TRUE; + s->features.shaderStorageImageWriteWithoutFormat = VK_TRUE; + s->features.shaderTessellationAndGeometryPointSize = VK_TRUE; + s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; + s->features.tessellationShader = VK_TRUE; + s->features.textureCompressionBC = VK_TRUE; + s->features.vertexPipelineStoresAndAtomics = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: + { + VkPhysicalDeviceRobustness2FeaturesEXT *s = static_cast(static_cast(p)); + s->robustImageAccess2 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: + { + VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *s = static_cast(static_cast(p)); + s->shaderBufferFloat32Atomics = VK_TRUE; + s->shaderSharedFloat32Atomics = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + { + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *s = static_cast(static_cast(p)); + s->texelBufferAlignment = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: + { + VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *s = static_cast(static_cast(p)); + s->vertexAttributeInstanceRateDivisor = VK_TRUE; + s->vertexAttributeInstanceRateZeroDivisor = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *s = static_cast(static_cast(p)); + s->multiview = VK_TRUE; + s->protectedMemory = VK_FALSE; + s->shaderDrawParameters = VK_TRUE; + s->storageBuffer16BitAccess = VK_TRUE; + s->uniformAndStorageBuffer16BitAccess = VK_TRUE; + s->variablePointers = VK_TRUE; + s->variablePointersStorageBuffer = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *s = static_cast(static_cast(p)); + s->bufferDeviceAddress = VK_TRUE; + s->descriptorBindingPartiallyBound = VK_TRUE; + s->descriptorBindingSampledImageUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageImageUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageTexelBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingUniformTexelBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingUpdateUnusedWhilePending = VK_TRUE; + s->descriptorBindingVariableDescriptorCount = VK_TRUE; + s->descriptorIndexing = VK_TRUE; + s->hostQueryReset = VK_TRUE; + s->imagelessFramebuffer = VK_TRUE; + s->runtimeDescriptorArray = VK_TRUE; + s->samplerMirrorClampToEdge = VK_TRUE; + s->scalarBlockLayout = VK_TRUE; + s->separateDepthStencilLayouts = VK_TRUE; + s->shaderInt8 = VK_TRUE; + s->shaderOutputLayer = VK_TRUE; + s->shaderOutputViewportIndex = VK_TRUE; + s->shaderSampledImageArrayNonUniformIndexing = VK_TRUE; + s->shaderStorageBufferArrayNonUniformIndexing = VK_TRUE; + s->shaderStorageImageArrayNonUniformIndexing = VK_TRUE; + s->shaderStorageTexelBufferArrayDynamicIndexing = VK_TRUE; + s->shaderStorageTexelBufferArrayNonUniformIndexing = VK_TRUE; + s->shaderSubgroupExtendedTypes = VK_TRUE; + s->shaderUniformTexelBufferArrayDynamicIndexing = VK_TRUE; + s->shaderUniformTexelBufferArrayNonUniformIndexing = VK_TRUE; + s->storageBuffer8BitAccess = VK_TRUE; + s->subgroupBroadcastDynamicId = VK_TRUE; + s->timelineSemaphore = VK_TRUE; + s->uniformAndStorageBuffer8BitAccess = VK_TRUE; + s->uniformBufferStandardLayout = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + { + VkPhysicalDevice4444FormatsFeaturesEXT *prettify_VkPhysicalDevice4444FormatsFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDevice4444FormatsFeaturesEXT->formatA4R4G4B4 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDevice4444FormatsFeaturesEXT->formatA4R4G4B4 == VK_TRUE), "Unsupported feature condition: VkPhysicalDevice4444FormatsFeaturesEXT::formatA4R4G4B4 == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + { + VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *prettify_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT->extendedDynamicState2 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT->extendedDynamicState2 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::extendedDynamicState2 == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + { + VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *prettify_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT->extendedDynamicState == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT->extendedDynamicState == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::extendedDynamicState == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthBiasClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.drawIndirectFirstInstance == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.dualSrcBlend == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.dualSrcBlend == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.dualSrcBlend == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fillModeNonSolid == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fillModeNonSolid == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fillModeNonSolid == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fragmentStoresAndAtomics == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fullDrawIndexUint32 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.imageCubeArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.independentBlend == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.inheritedQueries == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.inheritedQueries == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.inheritedQueries == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.largePoints == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.largePoints == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.largePoints == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.multiDrawIndirect == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.multiDrawIndirect == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.multiDrawIndirect == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.multiViewport == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.multiViewport == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.multiViewport == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.occlusionQueryPrecise == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.occlusionQueryPrecise == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.occlusionQueryPrecise == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.sampleRateShading == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.samplerAnisotropy == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderClipDistance == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderClipDistance == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderClipDistance == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderImageGatherExtended == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderImageGatherExtended == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderImageGatherExtended == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderInt16 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderInt16 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderInt16 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderSampledImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageExtendedFormats == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageWriteWithoutFormat == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageWriteWithoutFormat == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageWriteWithoutFormat == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderTessellationAndGeometryPointSize == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderTessellationAndGeometryPointSize == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderTessellationAndGeometryPointSize == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.tessellationShader == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.tessellationShader == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.tessellationShader == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionBC == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionBC == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.textureCompressionBC == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.vertexPipelineStoresAndAtomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.vertexPipelineStoresAndAtomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.vertexPipelineStoresAndAtomics == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: + { + VkPhysicalDeviceRobustness2FeaturesEXT *prettify_VkPhysicalDeviceRobustness2FeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceRobustness2FeaturesEXT->robustImageAccess2 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceRobustness2FeaturesEXT->robustImageAccess2 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceRobustness2FeaturesEXT::robustImageAccess2 == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: + { + VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *prettify_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT->shaderBufferFloat32Atomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT->shaderBufferFloat32Atomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::shaderBufferFloat32Atomics == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT->shaderSharedFloat32Atomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT->shaderSharedFloat32Atomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::shaderSharedFloat32Atomics == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + { + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *prettify_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT->texelBufferAlignment == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT->texelBufferAlignment == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::texelBufferAlignment == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: + { + VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateDivisor == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateDivisor == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::vertexAttributeInstanceRateDivisor == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateZeroDivisor == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateZeroDivisor == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::vertexAttributeInstanceRateZeroDivisor == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *prettify_VkPhysicalDeviceVulkan11Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::multiview == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->protectedMemory == VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->protectedMemory == VK_FALSE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::protectedMemory == VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->shaderDrawParameters == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->shaderDrawParameters == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::shaderDrawParameters == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->storageBuffer16BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->storageBuffer16BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::storageBuffer16BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->uniformAndStorageBuffer16BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->uniformAndStorageBuffer16BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::uniformAndStorageBuffer16BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->variablePointers == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->variablePointers == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::variablePointers == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->variablePointersStorageBuffer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->variablePointersStorageBuffer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::variablePointersStorageBuffer == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *prettify_VkPhysicalDeviceVulkan12Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->bufferDeviceAddress == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->bufferDeviceAddress == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::bufferDeviceAddress == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingPartiallyBound == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingPartiallyBound == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingPartiallyBound == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingSampledImageUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageImageUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUpdateUnusedWhilePending == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUpdateUnusedWhilePending == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingUpdateUnusedWhilePending == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingVariableDescriptorCount == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingVariableDescriptorCount == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingVariableDescriptorCount == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::hostQueryReset == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::imagelessFramebuffer == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->runtimeDescriptorArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->runtimeDescriptorArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::runtimeDescriptorArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->samplerMirrorClampToEdge == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->samplerMirrorClampToEdge == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::samplerMirrorClampToEdge == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->scalarBlockLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->scalarBlockLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::scalarBlockLayout == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::separateDepthStencilLayouts == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderInt8 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderInt8 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderInt8 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderOutputLayer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderOutputLayer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderOutputLayer == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderOutputViewportIndex == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderOutputViewportIndex == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderOutputViewportIndex == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderSampledImageArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderSampledImageArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderSampledImageArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageBufferArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageImageArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageImageArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageImageArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderSubgroupExtendedTypes == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderSubgroupExtendedTypes == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderSubgroupExtendedTypes == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->storageBuffer8BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->storageBuffer8BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::storageBuffer8BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->subgroupBroadcastDynamicId == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->subgroupBroadcastDynamicId == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::subgroupBroadcastDynamicId == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::timelineSemaphore == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->uniformAndStorageBuffer8BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->uniformAndStorageBuffer8BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::uniformAndStorageBuffer8BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::uniformBufferStandardLayout == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDevice4444FormatsFeaturesEXT physicalDevice4444FormatsFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT, nullptr}; + VkPhysicalDeviceExtendedDynamicState2FeaturesEXT physicalDeviceExtendedDynamicState2FeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT, &physicalDevice4444FormatsFeaturesEXT}; + VkPhysicalDeviceExtendedDynamicStateFeaturesEXT physicalDeviceExtendedDynamicStateFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT, &physicalDeviceExtendedDynamicState2FeaturesEXT}; + VkPhysicalDeviceRobustness2FeaturesEXT physicalDeviceRobustness2FeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, &physicalDeviceExtendedDynamicStateFeaturesEXT}; + VkPhysicalDeviceShaderAtomicFloatFeaturesEXT physicalDeviceShaderAtomicFloatFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT, &physicalDeviceRobustness2FeaturesEXT}; + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT physicalDeviceTexelBufferAlignmentFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, &physicalDeviceShaderAtomicFloatFeaturesEXT}; + VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT physicalDeviceVertexAttributeDivisorFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, &physicalDeviceTexelBufferAlignmentFeaturesEXT}; + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, &physicalDeviceVertexAttributeDivisorFeaturesEXT}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Features)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceExternalMemoryHostPropertiesEXT physicalDeviceExternalMemoryHostPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT, nullptr}; + VkPhysicalDeviceFloatControlsPropertiesKHR physicalDeviceFloatControlsPropertiesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR, &physicalDeviceExternalMemoryHostPropertiesEXT}; + VkPhysicalDeviceInlineUniformBlockPropertiesEXT physicalDeviceInlineUniformBlockPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT, &physicalDeviceFloatControlsPropertiesKHR}; + VkPhysicalDevicePushDescriptorPropertiesKHR physicalDevicePushDescriptorPropertiesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, &physicalDeviceInlineUniformBlockPropertiesEXT}; + VkPhysicalDeviceRobustness2PropertiesEXT physicalDeviceRobustness2PropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT, &physicalDevicePushDescriptorPropertiesKHR}; + VkPhysicalDeviceSubgroupSizeControlPropertiesEXT physicalDeviceSubgroupSizeControlPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT, &physicalDeviceRobustness2PropertiesEXT}; + VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT physicalDeviceTexelBufferAlignmentPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT, &physicalDeviceSubgroupSizeControlPropertiesEXT}; + VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT physicalDeviceVertexAttributeDivisorPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, &physicalDeviceTexelBufferAlignmentPropertiesEXT}; + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, &physicalDeviceVertexAttributeDivisorPropertiesEXT}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkFormatProperties3KHR formatProperties3KHR{VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr}; + p->pNext = static_cast(static_cast(&formatProperties3KHR)); + pfnCb(p, pUser); + }, +}; + +namespace blocks +{ +namespace VP_LUNARG_desktop_baseline_2024_block +{ + +static const VkExtensionProperties deviceExtensions[] = { + VkExtensionProperties{VK_EXT_4444_FORMATS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_MEMORY_BUDGET_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_PRIVATE_DATA_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_ROBUSTNESS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_KHR_16BIT_STORAGE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_8BIT_STORAGE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_BIND_MEMORY_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DEVICE_GROUP_EXTENSION_NAME, 4}, + VkExtensionProperties{VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_KHR_MAINTENANCE_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MAINTENANCE_3_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_MULTIVIEW_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME, 3}, + VkExtensionProperties{VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME, 4}, + VkExtensionProperties{VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SPIRV_1_4_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SWAPCHAIN_EXTENSION_NAME, 70}, + VkExtensionProperties{VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME, 2}, + VkExtensionProperties{VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME, 1}, + VkExtensionProperties{VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, 1}, }; +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + { + VkPhysicalDevice4444FormatsFeaturesEXT *s = static_cast(static_cast(p)); + s->formatA4R4G4B4 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + { + VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *s = static_cast(static_cast(p)); + s->extendedDynamicState2 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + { + VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *s = static_cast(static_cast(p)); + s->extendedDynamicState = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.depthBiasClamp = VK_TRUE; + s->features.depthClamp = VK_TRUE; + s->features.drawIndirectFirstInstance = VK_TRUE; + s->features.dualSrcBlend = VK_TRUE; + s->features.fillModeNonSolid = VK_TRUE; + s->features.fragmentStoresAndAtomics = VK_TRUE; + s->features.fullDrawIndexUint32 = VK_TRUE; + s->features.imageCubeArray = VK_TRUE; + s->features.independentBlend = VK_TRUE; + s->features.inheritedQueries = VK_TRUE; + s->features.largePoints = VK_TRUE; + s->features.multiDrawIndirect = VK_TRUE; + s->features.multiViewport = VK_TRUE; + s->features.occlusionQueryPrecise = VK_TRUE; + s->features.robustBufferAccess = VK_TRUE; + s->features.sampleRateShading = VK_TRUE; + s->features.samplerAnisotropy = VK_TRUE; + s->features.shaderClipDistance = VK_TRUE; + s->features.shaderImageGatherExtended = VK_TRUE; + s->features.shaderInt16 = VK_TRUE; + s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageBufferArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; + s->features.shaderStorageImageExtendedFormats = VK_TRUE; + s->features.shaderStorageImageWriteWithoutFormat = VK_TRUE; + s->features.shaderTessellationAndGeometryPointSize = VK_TRUE; + s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; + s->features.tessellationShader = VK_TRUE; + s->features.textureCompressionBC = VK_TRUE; + s->features.vertexPipelineStoresAndAtomics = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: + { + VkPhysicalDeviceRobustness2FeaturesEXT *s = static_cast(static_cast(p)); + s->robustImageAccess2 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: + { + VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *s = static_cast(static_cast(p)); + s->shaderBufferFloat32Atomics = VK_TRUE; + s->shaderSharedFloat32Atomics = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + { + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *s = static_cast(static_cast(p)); + s->texelBufferAlignment = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: + { + VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *s = static_cast(static_cast(p)); + s->vertexAttributeInstanceRateDivisor = VK_TRUE; + s->vertexAttributeInstanceRateZeroDivisor = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *s = static_cast(static_cast(p)); + s->multiview = VK_TRUE; + s->protectedMemory = VK_FALSE; + s->shaderDrawParameters = VK_TRUE; + s->storageBuffer16BitAccess = VK_TRUE; + s->uniformAndStorageBuffer16BitAccess = VK_TRUE; + s->variablePointers = VK_TRUE; + s->variablePointersStorageBuffer = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *s = static_cast(static_cast(p)); + s->bufferDeviceAddress = VK_TRUE; + s->descriptorBindingPartiallyBound = VK_TRUE; + s->descriptorBindingSampledImageUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageImageUpdateAfterBind = VK_TRUE; + s->descriptorBindingStorageTexelBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingUniformTexelBufferUpdateAfterBind = VK_TRUE; + s->descriptorBindingUpdateUnusedWhilePending = VK_TRUE; + s->descriptorBindingVariableDescriptorCount = VK_TRUE; + s->descriptorIndexing = VK_TRUE; + s->hostQueryReset = VK_TRUE; + s->imagelessFramebuffer = VK_TRUE; + s->runtimeDescriptorArray = VK_TRUE; + s->samplerMirrorClampToEdge = VK_TRUE; + s->scalarBlockLayout = VK_TRUE; + s->separateDepthStencilLayouts = VK_TRUE; + s->shaderInt8 = VK_TRUE; + s->shaderOutputLayer = VK_TRUE; + s->shaderOutputViewportIndex = VK_TRUE; + s->shaderSampledImageArrayNonUniformIndexing = VK_TRUE; + s->shaderStorageBufferArrayNonUniformIndexing = VK_TRUE; + s->shaderStorageImageArrayNonUniformIndexing = VK_TRUE; + s->shaderStorageTexelBufferArrayDynamicIndexing = VK_TRUE; + s->shaderStorageTexelBufferArrayNonUniformIndexing = VK_TRUE; + s->shaderSubgroupExtendedTypes = VK_TRUE; + s->shaderUniformTexelBufferArrayDynamicIndexing = VK_TRUE; + s->shaderUniformTexelBufferArrayNonUniformIndexing = VK_TRUE; + s->storageBuffer8BitAccess = VK_TRUE; + s->subgroupBroadcastDynamicId = VK_TRUE; + s->timelineSemaphore = VK_TRUE; + s->uniformAndStorageBuffer8BitAccess = VK_TRUE; + s->uniformBufferStandardLayout = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + { + VkPhysicalDevice4444FormatsFeaturesEXT *prettify_VkPhysicalDevice4444FormatsFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDevice4444FormatsFeaturesEXT->formatA4R4G4B4 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDevice4444FormatsFeaturesEXT->formatA4R4G4B4 == VK_TRUE), "Unsupported feature condition: VkPhysicalDevice4444FormatsFeaturesEXT::formatA4R4G4B4 == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + { + VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *prettify_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT->extendedDynamicState2 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT->extendedDynamicState2 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::extendedDynamicState2 == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + { + VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *prettify_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT->extendedDynamicState == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT->extendedDynamicState == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::extendedDynamicState == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthBiasClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthBiasClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.depthClamp == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.depthClamp == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.depthClamp == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.drawIndirectFirstInstance == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.drawIndirectFirstInstance == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.dualSrcBlend == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.dualSrcBlend == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.dualSrcBlend == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fillModeNonSolid == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fillModeNonSolid == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fillModeNonSolid == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fragmentStoresAndAtomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fragmentStoresAndAtomics == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.fullDrawIndexUint32 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.fullDrawIndexUint32 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.imageCubeArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.imageCubeArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.independentBlend == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.independentBlend == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.inheritedQueries == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.inheritedQueries == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.inheritedQueries == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.largePoints == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.largePoints == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.largePoints == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.multiDrawIndirect == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.multiDrawIndirect == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.multiDrawIndirect == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.multiViewport == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.multiViewport == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.multiViewport == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.occlusionQueryPrecise == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.occlusionQueryPrecise == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.occlusionQueryPrecise == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.sampleRateShading == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.sampleRateShading == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.samplerAnisotropy == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.samplerAnisotropy == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderClipDistance == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderClipDistance == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderClipDistance == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderImageGatherExtended == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderImageGatherExtended == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderImageGatherExtended == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderInt16 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderInt16 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderInt16 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderSampledImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageExtendedFormats == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageExtendedFormats == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageWriteWithoutFormat == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderStorageImageWriteWithoutFormat == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderStorageImageWriteWithoutFormat == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderTessellationAndGeometryPointSize == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderTessellationAndGeometryPointSize == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderTessellationAndGeometryPointSize == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.tessellationShader == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.tessellationShader == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.tessellationShader == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionBC == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.textureCompressionBC == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.textureCompressionBC == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.vertexPipelineStoresAndAtomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.vertexPipelineStoresAndAtomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.vertexPipelineStoresAndAtomics == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: + { + VkPhysicalDeviceRobustness2FeaturesEXT *prettify_VkPhysicalDeviceRobustness2FeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceRobustness2FeaturesEXT->robustImageAccess2 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceRobustness2FeaturesEXT->robustImageAccess2 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceRobustness2FeaturesEXT::robustImageAccess2 == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: + { + VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *prettify_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT->shaderBufferFloat32Atomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT->shaderBufferFloat32Atomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::shaderBufferFloat32Atomics == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT->shaderSharedFloat32Atomics == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT->shaderSharedFloat32Atomics == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::shaderSharedFloat32Atomics == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + { + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *prettify_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT->texelBufferAlignment == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT->texelBufferAlignment == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::texelBufferAlignment == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: + { + VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateDivisor == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateDivisor == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::vertexAttributeInstanceRateDivisor == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateZeroDivisor == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT->vertexAttributeInstanceRateZeroDivisor == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::vertexAttributeInstanceRateZeroDivisor == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *prettify_VkPhysicalDeviceVulkan11Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::multiview == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->protectedMemory == VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->protectedMemory == VK_FALSE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::protectedMemory == VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->shaderDrawParameters == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->shaderDrawParameters == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::shaderDrawParameters == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->storageBuffer16BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->storageBuffer16BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::storageBuffer16BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->uniformAndStorageBuffer16BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->uniformAndStorageBuffer16BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::uniformAndStorageBuffer16BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->variablePointers == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->variablePointers == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::variablePointers == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->variablePointersStorageBuffer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->variablePointersStorageBuffer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::variablePointersStorageBuffer == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *prettify_VkPhysicalDeviceVulkan12Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->bufferDeviceAddress == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->bufferDeviceAddress == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::bufferDeviceAddress == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingPartiallyBound == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingPartiallyBound == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingPartiallyBound == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingSampledImageUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageImageUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUpdateUnusedWhilePending == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingUpdateUnusedWhilePending == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingUpdateUnusedWhilePending == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingVariableDescriptorCount == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorBindingVariableDescriptorCount == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorBindingVariableDescriptorCount == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->descriptorIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->descriptorIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::descriptorIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::hostQueryReset == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::imagelessFramebuffer == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->runtimeDescriptorArray == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->runtimeDescriptorArray == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::runtimeDescriptorArray == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->samplerMirrorClampToEdge == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->samplerMirrorClampToEdge == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::samplerMirrorClampToEdge == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->scalarBlockLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->scalarBlockLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::scalarBlockLayout == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::separateDepthStencilLayouts == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderInt8 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderInt8 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderInt8 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderOutputLayer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderOutputLayer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderOutputLayer == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderOutputViewportIndex == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderOutputViewportIndex == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderOutputViewportIndex == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderSampledImageArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderSampledImageArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderSampledImageArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageBufferArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageImageArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageImageArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageImageArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderSubgroupExtendedTypes == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderSubgroupExtendedTypes == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderSubgroupExtendedTypes == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->storageBuffer8BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->storageBuffer8BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::storageBuffer8BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->subgroupBroadcastDynamicId == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->subgroupBroadcastDynamicId == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::subgroupBroadcastDynamicId == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::timelineSemaphore == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->uniformAndStorageBuffer8BitAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->uniformAndStorageBuffer8BitAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::uniformAndStorageBuffer8BitAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::uniformBufferStandardLayout == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: + { + VkPhysicalDeviceExternalMemoryHostPropertiesEXT *s = static_cast(static_cast(p)); + s->minImportedHostPointerAlignment = 4096; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR: + { + VkPhysicalDeviceFloatControlsPropertiesKHR *s = static_cast(static_cast(p)); + s->shaderDenormFlushToZeroFloat16 = VK_FALSE; + s->shaderDenormFlushToZeroFloat32 = VK_FALSE; + s->shaderDenormFlushToZeroFloat64 = VK_FALSE; + s->shaderDenormPreserveFloat16 = VK_TRUE; + s->shaderDenormPreserveFloat32 = VK_FALSE; + s->shaderDenormPreserveFloat64 = VK_FALSE; + s->shaderRoundingModeRTEFloat16 = VK_TRUE; + s->shaderRoundingModeRTEFloat32 = VK_TRUE; + s->shaderRoundingModeRTEFloat64 = VK_TRUE; + s->shaderRoundingModeRTZFloat16 = VK_FALSE; + s->shaderRoundingModeRTZFloat32 = VK_TRUE; + s->shaderRoundingModeRTZFloat64 = VK_TRUE; + s->shaderSignedZeroInfNanPreserveFloat16 = VK_TRUE; + s->shaderSignedZeroInfNanPreserveFloat32 = VK_TRUE; + s->shaderSignedZeroInfNanPreserveFloat64 = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: + { + VkPhysicalDeviceInlineUniformBlockPropertiesEXT *s = static_cast(static_cast(p)); + s->maxDescriptorSetInlineUniformBlocks = 4; + s->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = 4; + s->maxInlineUniformBlockSize = 256; + s->maxPerStageDescriptorInlineUniformBlocks = 4; + s->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = 4; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *s = static_cast(static_cast(p)); + s->properties.limits.bufferImageGranularity = 1024; + s->properties.limits.discreteQueuePriorities = 2; + s->properties.limits.framebufferColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferNoAttachmentsSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.lineWidthGranularity = 0.125f; + s->properties.limits.lineWidthRange[0] = 1; + s->properties.limits.lineWidthRange[1] = 1; + s->properties.limits.maxBoundDescriptorSets = 8; + s->properties.limits.maxClipDistances = 8; + s->properties.limits.maxColorAttachments = 8; + s->properties.limits.maxCombinedClipAndCullDistances = 8; + s->properties.limits.maxComputeSharedMemorySize = 32768; + s->properties.limits.maxComputeWorkGroupCount[0] = 65535; + s->properties.limits.maxComputeWorkGroupCount[1] = 65535; + s->properties.limits.maxComputeWorkGroupCount[2] = 65535; + s->properties.limits.maxComputeWorkGroupInvocations = 1024; + s->properties.limits.maxComputeWorkGroupSize[0] = 1024; + s->properties.limits.maxComputeWorkGroupSize[1] = 1024; + s->properties.limits.maxComputeWorkGroupSize[2] = 64; + s->properties.limits.maxCullDistances = 0; + s->properties.limits.maxDescriptorSetInputAttachments = 7; + s->properties.limits.maxDescriptorSetSampledImages = 640; + s->properties.limits.maxDescriptorSetSamplers = 80; + s->properties.limits.maxDescriptorSetStorageBuffers = 155; + s->properties.limits.maxDescriptorSetStorageBuffersDynamic = 8; + s->properties.limits.maxDescriptorSetStorageImages = 40; + s->properties.limits.maxDescriptorSetUniformBuffers = 155; + s->properties.limits.maxDescriptorSetUniformBuffersDynamic = 8; + s->properties.limits.maxDrawIndexedIndexValue = 4294967295; + s->properties.limits.maxDrawIndirectCount = 1073741824; + s->properties.limits.maxFragmentCombinedOutputResources = 16; + s->properties.limits.maxFragmentDualSrcAttachments = 1; + s->properties.limits.maxFragmentInputComponents = 116; + s->properties.limits.maxFragmentOutputAttachments = 8; + s->properties.limits.maxFramebufferHeight = 16384; + s->properties.limits.maxFramebufferLayers = 1024; + s->properties.limits.maxFramebufferWidth = 16384; + s->properties.limits.maxGeometryInputComponents = 0; + s->properties.limits.maxGeometryOutputComponents = 0; + s->properties.limits.maxGeometryOutputVertices = 0; + s->properties.limits.maxGeometryShaderInvocations = 0; + s->properties.limits.maxGeometryTotalOutputComponents = 0; + s->properties.limits.maxImageArrayLayers = 2048; + s->properties.limits.maxImageDimension1D = 16384; + s->properties.limits.maxImageDimension2D = 16384; + s->properties.limits.maxImageDimension3D = 2048; + s->properties.limits.maxImageDimensionCube = 16384; + s->properties.limits.maxInterpolationOffset = 0.4375f; + s->properties.limits.maxMemoryAllocationCount = 4096; + s->properties.limits.maxPerStageDescriptorInputAttachments = 7; + s->properties.limits.maxPerStageDescriptorSampledImages = 128; + s->properties.limits.maxPerStageDescriptorSamplers = 16; + s->properties.limits.maxPerStageDescriptorStorageBuffers = 31; + s->properties.limits.maxPerStageDescriptorStorageImages = 8; + s->properties.limits.maxPerStageDescriptorUniformBuffers = 15; + s->properties.limits.maxPerStageResources = 159; + s->properties.limits.maxPushConstantsSize = 128; + s->properties.limits.maxSampleMaskWords = 1; + s->properties.limits.maxSamplerAllocationCount = 4000; + s->properties.limits.maxSamplerAnisotropy = 16; + s->properties.limits.maxSamplerLodBias = 4.0f; + s->properties.limits.maxStorageBufferRange = 1073741820; + s->properties.limits.maxTessellationControlPerPatchOutputComponents = 120; + s->properties.limits.maxTessellationControlPerVertexInputComponents = 124; + s->properties.limits.maxTessellationControlPerVertexOutputComponents = 124; + s->properties.limits.maxTessellationControlTotalOutputComponents = 2048; + s->properties.limits.maxTessellationEvaluationInputComponents = 124; + s->properties.limits.maxTessellationEvaluationOutputComponents = 124; + s->properties.limits.maxTessellationGenerationLevel = 64; + s->properties.limits.maxTessellationPatchSize = 32; + s->properties.limits.maxTexelBufferElements = 67108864; + s->properties.limits.maxTexelGatherOffset = 7; + s->properties.limits.maxTexelOffset = 7; + s->properties.limits.maxUniformBufferRange = 65536; + s->properties.limits.maxVertexInputAttributeOffset = 2047; + s->properties.limits.maxVertexInputAttributes = 29; + s->properties.limits.maxVertexInputBindingStride = 2048; + s->properties.limits.maxVertexInputBindings = 31; + s->properties.limits.maxVertexOutputComponents = 124; + s->properties.limits.maxViewportDimensions[0] = 16384; + s->properties.limits.maxViewportDimensions[1] = 16384; + s->properties.limits.maxViewports = 16; + s->properties.limits.minInterpolationOffset = -0.5f; + s->properties.limits.minMemoryMapAlignment = 64; + s->properties.limits.minStorageBufferOffsetAlignment = 64; + s->properties.limits.minTexelBufferOffsetAlignment = 64; + s->properties.limits.minTexelGatherOffset = -8; + s->properties.limits.minTexelOffset = -8; + s->properties.limits.minUniformBufferOffsetAlignment = 256; + s->properties.limits.mipmapPrecisionBits = 4; + s->properties.limits.nonCoherentAtomSize = 128; + s->properties.limits.optimalBufferCopyOffsetAlignment = 128; + s->properties.limits.optimalBufferCopyRowPitchAlignment = 128; + s->properties.limits.pointSizeGranularity = 1.0f; + s->properties.limits.pointSizeRange[0] = 1; + s->properties.limits.pointSizeRange[1] = 255.875f; + s->properties.limits.sampledImageColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageIntegerSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sparseAddressSpaceSize = 0; + s->properties.limits.standardSampleLocations = VK_TRUE; + s->properties.limits.storageImageSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); + s->properties.limits.strictLines = VK_FALSE; + s->properties.limits.subPixelInterpolationOffsetBits = 4; + s->properties.limits.subPixelPrecisionBits = 4; + s->properties.limits.subTexelPrecisionBits = 4; + s->properties.limits.timestampComputeAndGraphics = VK_TRUE; + s->properties.limits.viewportBoundsRange[0] = -32768; + s->properties.limits.viewportBoundsRange[1] = 32767; + s->properties.limits.viewportSubPixelBits = 0; + s->properties.sparseProperties.residencyAlignedMipSize = VK_FALSE; + s->properties.sparseProperties.residencyNonResidentStrict = VK_FALSE; + s->properties.sparseProperties.residencyStandard2DBlockShape = VK_FALSE; + s->properties.sparseProperties.residencyStandard2DMultisampleBlockShape = VK_FALSE; + s->properties.sparseProperties.residencyStandard3DBlockShape = VK_FALSE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: + { + VkPhysicalDevicePushDescriptorPropertiesKHR *s = static_cast(static_cast(p)); + s->maxPushDescriptors = 32; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: + { + VkPhysicalDeviceRobustness2PropertiesEXT *s = static_cast(static_cast(p)); + s->robustStorageBufferAccessSizeAlignment = 4; + s->robustUniformBufferAccessSizeAlignment = 256; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: + { + VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *s = static_cast(static_cast(p)); + s->maxComputeWorkgroupSubgroups = 32; + s->maxSubgroupSize = 32; + s->minSubgroupSize = 64; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: + { + VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *s = static_cast(static_cast(p)); + s->storageTexelBufferOffsetAlignmentBytes = 16; + s->uniformTexelBufferOffsetAlignmentBytes = 16; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: + { + VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *s = static_cast(static_cast(p)); + s->maxVertexAttribDivisor = 268435455; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + { + VkPhysicalDeviceVulkan11Properties *s = static_cast(static_cast(p)); + s->maxMemoryAllocationSize = 2147483648; + s->maxMultiviewInstanceIndex = 134217727; + s->maxMultiviewViewCount = 6; + s->maxPerSetDescriptors = 1024; + s->subgroupQuadOperationsInAllStages = VK_TRUE; + s->subgroupSize = 32; + s->subgroupSupportedOperations |= (VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT | VK_SUBGROUP_FEATURE_QUAD_BIT); + s->subgroupSupportedStages |= (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + { + VkPhysicalDeviceVulkan12Properties *s = static_cast(static_cast(p)); + s->filterMinmaxImageComponentMapping = VK_FALSE; + s->filterMinmaxSingleComponentFormats = VK_FALSE; + s->framebufferIntegerColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); + s->independentResolve = VK_TRUE; + s->independentResolveNone = VK_TRUE; + s->maxDescriptorSetUpdateAfterBindInputAttachments = 256; + s->maxDescriptorSetUpdateAfterBindSampledImages = 640; + s->maxDescriptorSetUpdateAfterBindSamplers = 80; + s->maxDescriptorSetUpdateAfterBindStorageBuffers = 155; + s->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = 8; + s->maxDescriptorSetUpdateAfterBindStorageImages = 40; + s->maxDescriptorSetUpdateAfterBindUniformBuffers = 155; + s->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = 8; + s->maxPerStageDescriptorUpdateAfterBindInputAttachments = 64; + s->maxPerStageDescriptorUpdateAfterBindSampledImages = 128; + s->maxPerStageDescriptorUpdateAfterBindSamplers = 16; + s->maxPerStageDescriptorUpdateAfterBindStorageBuffers = 31; + s->maxPerStageDescriptorUpdateAfterBindStorageImages = 8; + s->maxPerStageDescriptorUpdateAfterBindUniformBuffers = 15; + s->maxPerStageUpdateAfterBindResources = 159; + s->maxTimelineSemaphoreValueDifference = 2147483647; + s->maxUpdateAfterBindDescriptorsInAllPools = 1048576; + s->quadDivergentImplicitLod = VK_FALSE; + s->robustBufferAccessUpdateAfterBind = VK_TRUE; + s->shaderDenormFlushToZeroFloat16 = VK_FALSE; + s->shaderDenormFlushToZeroFloat32 = VK_FALSE; + s->shaderDenormFlushToZeroFloat64 = VK_FALSE; + s->shaderDenormPreserveFloat16 = VK_FALSE; + s->shaderDenormPreserveFloat32 = VK_FALSE; + s->shaderDenormPreserveFloat64 = VK_FALSE; + s->shaderInputAttachmentArrayNonUniformIndexingNative = VK_FALSE; + s->shaderRoundingModeRTEFloat16 = VK_FALSE; + s->shaderRoundingModeRTEFloat32 = VK_FALSE; + s->shaderRoundingModeRTEFloat64 = VK_FALSE; + s->shaderRoundingModeRTZFloat16 = VK_FALSE; + s->shaderRoundingModeRTZFloat32 = VK_FALSE; + s->shaderRoundingModeRTZFloat64 = VK_FALSE; + s->shaderSampledImageArrayNonUniformIndexingNative = VK_FALSE; + s->shaderSignedZeroInfNanPreserveFloat16 = VK_FALSE; + s->shaderSignedZeroInfNanPreserveFloat32 = VK_TRUE; + s->shaderSignedZeroInfNanPreserveFloat64 = VK_FALSE; + s->shaderStorageBufferArrayNonUniformIndexingNative = VK_FALSE; + s->shaderStorageImageArrayNonUniformIndexingNative = VK_FALSE; + s->shaderUniformBufferArrayNonUniformIndexingNative = VK_FALSE; + s->supportedDepthResolveModes |= (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT | VK_RESOLVE_MODE_MIN_BIT | VK_RESOLVE_MODE_MAX_BIT); + s->supportedStencilResolveModes |= (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: + { + VkPhysicalDeviceExternalMemoryHostPropertiesEXT *prettify_VkPhysicalDeviceExternalMemoryHostPropertiesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceExternalMemoryHostPropertiesEXT->minImportedHostPointerAlignment <= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceExternalMemoryHostPropertiesEXT->minImportedHostPointerAlignment <= 4096), "Unsupported properties condition: VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment <= 4096"); + ret = ret && ((prettify_VkPhysicalDeviceExternalMemoryHostPropertiesEXT->minImportedHostPointerAlignment & (prettify_VkPhysicalDeviceExternalMemoryHostPropertiesEXT->minImportedHostPointerAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceExternalMemoryHostPropertiesEXT->minImportedHostPointerAlignment & (prettify_VkPhysicalDeviceExternalMemoryHostPropertiesEXT->minImportedHostPointerAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceExternalMemoryHostPropertiesEXT->minImportedHostPointerAlignment & (prettify_VkPhysicalDeviceExternalMemoryHostPropertiesEXT->minImportedHostPointerAlignment - 1)) == 0"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR: + { + VkPhysicalDeviceFloatControlsPropertiesKHR *prettify_VkPhysicalDeviceFloatControlsPropertiesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderDenormFlushToZeroFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderDenormFlushToZeroFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceFloatControlsPropertiesKHR::shaderDenormFlushToZeroFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderDenormFlushToZeroFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderDenormFlushToZeroFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceFloatControlsPropertiesKHR::shaderDenormFlushToZeroFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderDenormFlushToZeroFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderDenormFlushToZeroFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceFloatControlsPropertiesKHR::shaderDenormFlushToZeroFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderDenormPreserveFloat16 >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderDenormPreserveFloat16 >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceFloatControlsPropertiesKHR::shaderDenormPreserveFloat16 >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderDenormPreserveFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderDenormPreserveFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceFloatControlsPropertiesKHR::shaderDenormPreserveFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderDenormPreserveFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderDenormPreserveFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceFloatControlsPropertiesKHR::shaderDenormPreserveFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderRoundingModeRTEFloat16 >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderRoundingModeRTEFloat16 >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceFloatControlsPropertiesKHR::shaderRoundingModeRTEFloat16 >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderRoundingModeRTEFloat32 >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderRoundingModeRTEFloat32 >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceFloatControlsPropertiesKHR::shaderRoundingModeRTEFloat32 >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderRoundingModeRTEFloat64 >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderRoundingModeRTEFloat64 >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceFloatControlsPropertiesKHR::shaderRoundingModeRTEFloat64 >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderRoundingModeRTZFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderRoundingModeRTZFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceFloatControlsPropertiesKHR::shaderRoundingModeRTZFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderRoundingModeRTZFloat32 >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderRoundingModeRTZFloat32 >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceFloatControlsPropertiesKHR::shaderRoundingModeRTZFloat32 >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderRoundingModeRTZFloat64 >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderRoundingModeRTZFloat64 >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceFloatControlsPropertiesKHR::shaderRoundingModeRTZFloat64 >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderSignedZeroInfNanPreserveFloat16 >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderSignedZeroInfNanPreserveFloat16 >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceFloatControlsPropertiesKHR::shaderSignedZeroInfNanPreserveFloat16 >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderSignedZeroInfNanPreserveFloat32 >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderSignedZeroInfNanPreserveFloat32 >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceFloatControlsPropertiesKHR::shaderSignedZeroInfNanPreserveFloat32 >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderSignedZeroInfNanPreserveFloat64 >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFloatControlsPropertiesKHR->shaderSignedZeroInfNanPreserveFloat64 >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceFloatControlsPropertiesKHR::shaderSignedZeroInfNanPreserveFloat64 >= VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: + { + VkPhysicalDeviceInlineUniformBlockPropertiesEXT *prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxDescriptorSetInlineUniformBlocks >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxDescriptorSetInlineUniformBlocks >= 4), "Unsupported properties condition: VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxDescriptorSetInlineUniformBlocks >= 4"); + ret = ret && (prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxDescriptorSetUpdateAfterBindInlineUniformBlocks >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxDescriptorSetUpdateAfterBindInlineUniformBlocks >= 4), "Unsupported properties condition: VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxDescriptorSetUpdateAfterBindInlineUniformBlocks >= 4"); + ret = ret && (prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxInlineUniformBlockSize >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxInlineUniformBlockSize >= 256), "Unsupported properties condition: VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxInlineUniformBlockSize >= 256"); + ret = ret && (prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxPerStageDescriptorInlineUniformBlocks >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxPerStageDescriptorInlineUniformBlocks >= 4), "Unsupported properties condition: VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxPerStageDescriptorInlineUniformBlocks >= 4"); + ret = ret && (prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceInlineUniformBlockPropertiesEXT->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks >= 4), "Unsupported properties condition: VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks >= 4"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *prettify_VkPhysicalDeviceProperties2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity <= 1024); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity <= 1024), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.bufferImageGranularity <= 1024"); + ret = ret && ((1024 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0); + VP_DEBUG_COND_MSG(!((1024 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0), "Unsupported properties condition: (1024 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.discreteQueuePriorities >= 2); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.discreteQueuePriorities >= 2), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.discreteQueuePriorities >= 2"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferDepthSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferNoAttachmentsSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferStencilSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity <= 0.125); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity <= 0.125), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthGranularity <= 0.125"); + ret = ret && (isMultiple(0.125, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)); + VP_DEBUG_COND_MSG(!(isMultiple(0.125, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)), "Unsupported properties condition: isMultiple(0.125, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[0] <= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[0] <= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthRange[0] <= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[1] >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[1] >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthRange[1] >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxBoundDescriptorSets >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxClipDistances >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxClipDistances >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxClipDistances >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxColorAttachments >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCombinedClipAndCullDistances >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCombinedClipAndCullDistances >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxCombinedClipAndCullDistances >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeSharedMemorySize >= 32768); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeSharedMemorySize >= 32768), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeSharedMemorySize >= 32768"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[0] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[0] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[0] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[1] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[1] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[1] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[2] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[2] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[2] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 1024); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 1024), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupInvocations >= 1024"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 1024); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 1024), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[0] >= 1024"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 1024); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 1024), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[1] >= 1024"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[2] >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCullDistances >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCullDistances >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxCullDistances >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetInputAttachments >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetInputAttachments >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetInputAttachments >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 640); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 640), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSampledImages >= 640"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 80); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 80), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSamplers >= 80"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 155); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 155), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffers >= 155"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffersDynamic >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 40); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 40), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageImages >= 40"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 155); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 155), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffers >= 155"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndexedIndexValue >= 4294967295); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndexedIndexValue >= 4294967295), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDrawIndexedIndexValue >= 4294967295"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndirectCount >= 1073741824); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndirectCount >= 1073741824), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDrawIndirectCount >= 1073741824"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentCombinedOutputResources >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentDualSrcAttachments >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentDualSrcAttachments >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentDualSrcAttachments >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentInputComponents >= 116); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentInputComponents >= 116), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentInputComponents >= 116"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentOutputAttachments >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentOutputAttachments >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentOutputAttachments >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferHeight >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferHeight >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferHeight >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferLayers >= 1024); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferLayers >= 1024), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferLayers >= 1024"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferWidth >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferWidth >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferWidth >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryInputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryInputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryInputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputVertices >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputVertices >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryOutputVertices >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryShaderInvocations >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryShaderInvocations >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryShaderInvocations >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryTotalOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryTotalOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryTotalOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageArrayLayers >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension1D >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension2D >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension3D >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension3D >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension3D >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimensionCube >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxInterpolationOffset >= 0.4375); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxInterpolationOffset >= 0.4375), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxInterpolationOffset >= 0.4375"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxMemoryAllocationCount >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxMemoryAllocationCount >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxMemoryAllocationCount >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorInputAttachments >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorInputAttachments >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorInputAttachments >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSampledImages >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSamplers >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 31); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 31), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageBuffers >= 31"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageImages >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 15); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 15), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorUniformBuffers >= 15"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 159); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 159), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageResources >= 159"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPushConstantsSize >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPushConstantsSize >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPushConstantsSize >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSampleMaskWords >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSampleMaskWords >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSampleMaskWords >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAllocationCount >= 4000); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAllocationCount >= 4000), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerAllocationCount >= 4000"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAnisotropy >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAnisotropy >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerAnisotropy >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 4.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 4.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerLodBias >= 4.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxStorageBufferRange >= 1073741820); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxStorageBufferRange >= 1073741820), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxStorageBufferRange >= 1073741820"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerPatchOutputComponents >= 120); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerPatchOutputComponents >= 120), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerPatchOutputComponents >= 120"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexInputComponents >= 124); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexInputComponents >= 124), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerVertexInputComponents >= 124"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexOutputComponents >= 124); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexOutputComponents >= 124), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerVertexOutputComponents >= 124"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlTotalOutputComponents >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlTotalOutputComponents >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlTotalOutputComponents >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationInputComponents >= 124); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationInputComponents >= 124), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationEvaluationInputComponents >= 124"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationOutputComponents >= 124); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationOutputComponents >= 124), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationEvaluationOutputComponents >= 124"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationGenerationLevel >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationGenerationLevel >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationGenerationLevel >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationPatchSize >= 32); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationPatchSize >= 32), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationPatchSize >= 32"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelBufferElements >= 67108864); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelBufferElements >= 67108864), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelBufferElements >= 67108864"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelGatherOffset >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelGatherOffset >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelGatherOffset >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelOffset >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelOffset >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelOffset >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 65536); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 65536), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxUniformBufferRange >= 65536"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributeOffset >= 2047); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributeOffset >= 2047), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputAttributeOffset >= 2047"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributes >= 29); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributes >= 29), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputAttributes >= 29"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindingStride >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindingStride >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputBindingStride >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindings >= 31); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindings >= 31), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputBindings >= 31"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 124); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 124), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexOutputComponents >= 124"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[0] >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[0] >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewportDimensions[0] >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[1] >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[1] >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewportDimensions[1] >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewports >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewports >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewports >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minInterpolationOffset <= -0.5); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minInterpolationOffset <= -0.5), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minInterpolationOffset <= -0.5"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minMemoryMapAlignment >= 64"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment <= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment <= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minStorageBufferOffsetAlignment <= 64"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment <= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment <= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelBufferOffsetAlignment <= 64"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelGatherOffset <= -8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelGatherOffset <= -8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelGatherOffset <= -8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelOffset <= -8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelOffset <= -8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelOffset <= -8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minUniformBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.mipmapPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize <= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize <= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.nonCoherentAtomSize <= 128"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment <= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment <= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.optimalBufferCopyOffsetAlignment <= 128"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment <= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment <= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.optimalBufferCopyRowPitchAlignment <= 128"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.optimalBufferCopyRowPitchAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeGranularity <= 1.0"); + ret = ret && (isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)); + VP_DEBUG_COND_MSG(!(isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)), "Unsupported properties condition: isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[0] <= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[0] <= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeRange[0] <= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[1] >= 255.875); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[1] >= 255.875), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeRange[1] >= 255.875"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageDepthSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageIntegerSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageStencilSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sparseAddressSpaceSize >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sparseAddressSpaceSize >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sparseAddressSpaceSize >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.standardSampleLocations >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.standardSampleLocations >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.standardSampleLocations >= VK_TRUE"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.storageImageSampleCounts contains (VK_SAMPLE_COUNT_1_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.strictLines >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.strictLines >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.strictLines >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelInterpolationOffsetBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelInterpolationOffsetBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subPixelInterpolationOffsetBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subPixelPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subTexelPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.timestampComputeAndGraphics >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.timestampComputeAndGraphics >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.timestampComputeAndGraphics >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[0] <= -32768); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[0] <= -32768), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportBoundsRange[0] <= -32768"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[1] >= 32767); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[1] >= 32767), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportBoundsRange[1] >= 32767"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportSubPixelBits >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportSubPixelBits >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportSubPixelBits >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyAlignedMipSize <= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyAlignedMipSize <= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyAlignedMipSize <= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: + { + VkPhysicalDevicePushDescriptorPropertiesKHR *prettify_VkPhysicalDevicePushDescriptorPropertiesKHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDevicePushDescriptorPropertiesKHR->maxPushDescriptors >= 32); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDevicePushDescriptorPropertiesKHR->maxPushDescriptors >= 32), "Unsupported properties condition: VkPhysicalDevicePushDescriptorPropertiesKHR::maxPushDescriptors >= 32"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: + { + VkPhysicalDeviceRobustness2PropertiesEXT *prettify_VkPhysicalDeviceRobustness2PropertiesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustStorageBufferAccessSizeAlignment <= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustStorageBufferAccessSizeAlignment <= 4), "Unsupported properties condition: VkPhysicalDeviceRobustness2PropertiesEXT::robustStorageBufferAccessSizeAlignment <= 4"); + ret = ret && ((prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustStorageBufferAccessSizeAlignment & (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustStorageBufferAccessSizeAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustStorageBufferAccessSizeAlignment & (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustStorageBufferAccessSizeAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustStorageBufferAccessSizeAlignment & (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustStorageBufferAccessSizeAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustUniformBufferAccessSizeAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustUniformBufferAccessSizeAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceRobustness2PropertiesEXT::robustUniformBufferAccessSizeAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustUniformBufferAccessSizeAlignment & (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustUniformBufferAccessSizeAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustUniformBufferAccessSizeAlignment & (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustUniformBufferAccessSizeAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustUniformBufferAccessSizeAlignment & (prettify_VkPhysicalDeviceRobustness2PropertiesEXT->robustUniformBufferAccessSizeAlignment - 1)) == 0"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: + { + VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxComputeWorkgroupSubgroups >= 32); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxComputeWorkgroupSubgroups >= 32), "Unsupported properties condition: VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::maxComputeWorkgroupSubgroups >= 32"); + ret = ret && (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxSubgroupSize >= 32); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxSubgroupSize >= 32), "Unsupported properties condition: VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::maxSubgroupSize >= 32"); + ret = ret && ((prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxSubgroupSize & (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxSubgroupSize - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxSubgroupSize & (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxSubgroupSize - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxSubgroupSize & (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->maxSubgroupSize - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->minSubgroupSize <= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->minSubgroupSize <= 64), "Unsupported properties condition: VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::minSubgroupSize <= 64"); + ret = ret && ((prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->minSubgroupSize & (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->minSubgroupSize - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->minSubgroupSize & (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->minSubgroupSize - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->minSubgroupSize & (prettify_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT->minSubgroupSize - 1)) == 0"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: + { + VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->storageTexelBufferOffsetAlignmentBytes <= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->storageTexelBufferOffsetAlignmentBytes <= 16), "Unsupported properties condition: VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::storageTexelBufferOffsetAlignmentBytes <= 16"); + ret = ret && ((prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->storageTexelBufferOffsetAlignmentBytes & (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->storageTexelBufferOffsetAlignmentBytes - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->storageTexelBufferOffsetAlignmentBytes & (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->storageTexelBufferOffsetAlignmentBytes - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->storageTexelBufferOffsetAlignmentBytes & (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->storageTexelBufferOffsetAlignmentBytes - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->uniformTexelBufferOffsetAlignmentBytes <= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->uniformTexelBufferOffsetAlignmentBytes <= 16), "Unsupported properties condition: VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::uniformTexelBufferOffsetAlignmentBytes <= 16"); + ret = ret && ((prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->uniformTexelBufferOffsetAlignmentBytes & (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->uniformTexelBufferOffsetAlignmentBytes - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->uniformTexelBufferOffsetAlignmentBytes & (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->uniformTexelBufferOffsetAlignmentBytes - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->uniformTexelBufferOffsetAlignmentBytes & (prettify_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT->uniformTexelBufferOffsetAlignmentBytes - 1)) == 0"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: + { + VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *prettify_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT->maxVertexAttribDivisor >= 268435455); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT->maxVertexAttribDivisor >= 268435455), "Unsupported properties condition: VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::maxVertexAttribDivisor >= 268435455"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + { + VkPhysicalDeviceVulkan11Properties *prettify_VkPhysicalDeviceVulkan11Properties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->maxMemoryAllocationSize >= 2147483648); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->maxMemoryAllocationSize >= 2147483648), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::maxMemoryAllocationSize >= 2147483648"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewInstanceIndex >= 134217727); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewInstanceIndex >= 134217727), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::maxMultiviewInstanceIndex >= 134217727"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewViewCount >= 6); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewViewCount >= 6), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::maxMultiviewViewCount >= 6"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->maxPerSetDescriptors >= 1024); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->maxPerSetDescriptors >= 1024), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::maxPerSetDescriptors >= 1024"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->subgroupQuadOperationsInAllStages >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->subgroupQuadOperationsInAllStages >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::subgroupQuadOperationsInAllStages >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize >= 32); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize >= 32), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::subgroupSize >= 32"); + ret = ret && ((prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize & (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize & (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize & (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize - 1)) == 0"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT | VK_SUBGROUP_FEATURE_QUAD_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT | VK_SUBGROUP_FEATURE_QUAD_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::subgroupSupportedOperations contains (VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT | VK_SUBGROUP_FEATURE_QUAD_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedStages, (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedStages, (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::subgroupSupportedStages contains (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT)"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + { + VkPhysicalDeviceVulkan12Properties *prettify_VkPhysicalDeviceVulkan12Properties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->filterMinmaxImageComponentMapping >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->filterMinmaxImageComponentMapping >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::filterMinmaxImageComponentMapping >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->filterMinmaxSingleComponentFormats >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->filterMinmaxSingleComponentFormats >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::filterMinmaxSingleComponentFormats >= VK_FALSE"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan12Properties->framebufferIntegerColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan12Properties->framebufferIntegerColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::framebufferIntegerColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->independentResolve >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->independentResolve >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::independentResolve >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->independentResolveNone >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->independentResolveNone >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::independentResolveNone >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindInputAttachments >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindInputAttachments >= 256), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindInputAttachments >= 256"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSampledImages >= 640); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSampledImages >= 640), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindSampledImages >= 640"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSamplers >= 80); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSamplers >= 80), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindSamplers >= 80"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffers >= 155); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffers >= 155), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindStorageBuffers >= 155"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 8), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 8"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageImages >= 40); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageImages >= 40), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindStorageImages >= 40"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffers >= 155); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffers >= 155), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindUniformBuffers >= 155"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 8), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 8"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindInputAttachments >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindInputAttachments >= 64), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindInputAttachments >= 64"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSampledImages >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSampledImages >= 128), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindSampledImages >= 128"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSamplers >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSamplers >= 16), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindSamplers >= 16"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 31); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 31), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 31"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageImages >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageImages >= 8), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindStorageImages >= 8"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 15); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 15), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 15"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageUpdateAfterBindResources >= 159); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageUpdateAfterBindResources >= 159), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageUpdateAfterBindResources >= 159"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxTimelineSemaphoreValueDifference >= 2147483647); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxTimelineSemaphoreValueDifference >= 2147483647), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxTimelineSemaphoreValueDifference >= 2147483647"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxUpdateAfterBindDescriptorsInAllPools >= 1048576); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxUpdateAfterBindDescriptorsInAllPools >= 1048576), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxUpdateAfterBindDescriptorsInAllPools >= 1048576"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->quadDivergentImplicitLod >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->quadDivergentImplicitLod >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::quadDivergentImplicitLod >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->robustBufferAccessUpdateAfterBind >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->robustBufferAccessUpdateAfterBind >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::robustBufferAccessUpdateAfterBind >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormFlushToZeroFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormFlushToZeroFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormFlushToZeroFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormPreserveFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormPreserveFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormPreserveFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderInputAttachmentArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderInputAttachmentArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderInputAttachmentArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTEFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTEFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTEFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTZFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTZFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTZFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderSampledImageArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderSampledImageArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderSampledImageArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderSignedZeroInfNanPreserveFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat32 >= VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat32 >= VK_TRUE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderSignedZeroInfNanPreserveFloat32 >= VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderSignedZeroInfNanPreserveFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderStorageBufferArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderStorageBufferArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderStorageBufferArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderStorageImageArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderStorageImageArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderStorageImageArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderUniformBufferArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderUniformBufferArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderUniformBufferArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan12Properties->supportedDepthResolveModes, (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT | VK_RESOLVE_MODE_MIN_BIT | VK_RESOLVE_MODE_MAX_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan12Properties->supportedDepthResolveModes, (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT | VK_RESOLVE_MODE_MIN_BIT | VK_RESOLVE_MODE_MAX_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::supportedDepthResolveModes contains (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT | VK_RESOLVE_MODE_MIN_BIT | VK_RESOLVE_MODE_MAX_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan12Properties->supportedStencilResolveModes, (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan12Properties->supportedStencilResolveModes, (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::supportedStencilResolveModes contains (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT)"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpFormatDesc formatDesc[] = { + {VK_FORMAT_A1R5G5B5_UNORM_PACK16, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A1R5G5B5_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A1R5G5B5_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A2B10G10R10_SNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_SNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A2B10G10R10_UINT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A2B10G10R10_UNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A2R10G10B10_UNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A2R10G10B10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2R10G10B10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A2R10G10B10_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_SINT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_SNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_SRGB_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SRGB_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SRGB_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_SSCALED_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_SSCALED_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_UINT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_UNORM_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_A8B8G8R8_USCALED_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_A8B8G8R8_USCALED_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_B10G11R11_UFLOAT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_B4G4R4A4_UNORM_PACK16, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B4G4R4A4_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B4G4R4A4_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_B8G8R8A8_SRGB, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_SRGB: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_SRGB: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_B8G8R8A8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_B8G8R8A8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC1_RGBA_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC1_RGBA_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC1_RGBA_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC1_RGBA_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC1_RGB_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC1_RGB_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC1_RGB_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC1_RGB_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC2_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC2_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC2_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC2_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC3_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC3_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC3_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC3_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC4_SNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC4_SNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC4_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC4_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC5_SNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC5_SNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC5_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC5_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC6H_SFLOAT_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC6H_SFLOAT_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC6H_UFLOAT_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC6H_UFLOAT_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC7_SRGB_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC7_SRGB_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_BC7_UNORM_BLOCK, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_BC7_UNORM_BLOCK: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_D16_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_D16_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_D32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_D32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_D32_SFLOAT_S8_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_D32_SFLOAT_S8_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16A16_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16A16_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16B16_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16B16_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16G16_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16G16_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R16_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R16_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R16_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32A32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32A32_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32A32_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32A32_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32B32_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32B32_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32G32_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32G32_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32_SFLOAT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32_SFLOAT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SFLOAT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SFLOAT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R32_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R32_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R32_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R4G4B4A4_UNORM_PACK16, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R4G4B4A4_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R4G4B4A4_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R5G6B5_UNORM_PACK16, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R5G6B5_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R5G6B5_UNORM_PACK16: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_SRGB, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SRGB: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SRGB: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8A8_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8A8_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8B8_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8B8_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8G8_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8G8_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_SINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_SINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_SNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_SNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_SNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_SSCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_SSCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_UINT, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_UINT: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UINT: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UINT: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_UNORM, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_UNORM: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UNORM: VkFormatProperties2KHR::formatProperties.linearTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT))), "Unsupported format condition for VK_FORMAT_R8_UNORM: VkFormatProperties2KHR::formatProperties.optimalTilingFeatures contains (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)"); + } + break; + default: + break; + } + return ret; + }}, + {VK_FORMAT_R8_USCALED, + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *s = static_cast(static_cast(p)); + s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: + { + VkFormatProperties2KHR *prettify_VkFormatProperties2KHR = static_cast(static_cast(p)); + ret = ret && (vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkFormatProperties2KHR->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))), "Unsupported format condition for VK_FORMAT_R8_USCALED: VkFormatProperties2KHR::formatProperties.bufferFeatures contains (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)"); + } + break; + default: + break; + } + return ret; + }}, +}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDevice4444FormatsFeaturesEXT physicalDevice4444FormatsFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT, nullptr}; + VkPhysicalDeviceExtendedDynamicState2FeaturesEXT physicalDeviceExtendedDynamicState2FeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT, &physicalDevice4444FormatsFeaturesEXT}; + VkPhysicalDeviceExtendedDynamicStateFeaturesEXT physicalDeviceExtendedDynamicStateFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT, &physicalDeviceExtendedDynamicState2FeaturesEXT}; + VkPhysicalDeviceRobustness2FeaturesEXT physicalDeviceRobustness2FeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, &physicalDeviceExtendedDynamicStateFeaturesEXT}; + VkPhysicalDeviceShaderAtomicFloatFeaturesEXT physicalDeviceShaderAtomicFloatFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT, &physicalDeviceRobustness2FeaturesEXT}; + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT physicalDeviceTexelBufferAlignmentFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, &physicalDeviceShaderAtomicFloatFeaturesEXT}; + VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT physicalDeviceVertexAttributeDivisorFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, &physicalDeviceTexelBufferAlignmentFeaturesEXT}; + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, &physicalDeviceVertexAttributeDivisorFeaturesEXT}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Features)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceExternalMemoryHostPropertiesEXT physicalDeviceExternalMemoryHostPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT, nullptr}; + VkPhysicalDeviceFloatControlsPropertiesKHR physicalDeviceFloatControlsPropertiesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR, &physicalDeviceExternalMemoryHostPropertiesEXT}; + VkPhysicalDeviceInlineUniformBlockPropertiesEXT physicalDeviceInlineUniformBlockPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT, &physicalDeviceFloatControlsPropertiesKHR}; + VkPhysicalDevicePushDescriptorPropertiesKHR physicalDevicePushDescriptorPropertiesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, &physicalDeviceInlineUniformBlockPropertiesEXT}; + VkPhysicalDeviceRobustness2PropertiesEXT physicalDeviceRobustness2PropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT, &physicalDevicePushDescriptorPropertiesKHR}; + VkPhysicalDeviceSubgroupSizeControlPropertiesEXT physicalDeviceSubgroupSizeControlPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT, &physicalDeviceRobustness2PropertiesEXT}; + VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT physicalDeviceTexelBufferAlignmentPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT, &physicalDeviceSubgroupSizeControlPropertiesEXT}; + VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT physicalDeviceVertexAttributeDivisorPropertiesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, &physicalDeviceTexelBufferAlignmentPropertiesEXT}; + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, &physicalDeviceVertexAttributeDivisorPropertiesEXT}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkFormatProperties3KHR formatProperties3KHR{VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr}; + p->pNext = static_cast(static_cast(&formatProperties3KHR)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } }; +} // namespace VP_LUNARG_desktop_baseline_2024_block +} // namespace blocks +} // namespace VP_LUNARG_DESKTOP_BASELINE_2024 +#endif // VP_LUNARG_desktop_baseline_2024 + +#ifdef VP_LUNARG_minimum_requirements_1_0 +namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_0 +{ + +static const VkStructureType featureStructTypes[] = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, +}; + +static const VkStructureType propertyStructTypes[] = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, +}; + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.robustBufferAccess = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + p->pNext = static_cast(static_cast(nullptr)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + p->pNext = static_cast(static_cast(nullptr)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, }; -namespace vulkan10requirements { +namespace blocks +{ +namespace vulkan10requirements +{ + static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.robustBufferAccess = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.robustBufferAccess == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.robustBufferAccess = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *s = static_cast(static_cast(p)); + s->properties.limits.bufferImageGranularity = 131072; + s->properties.limits.discreteQueuePriorities = 2; + s->properties.limits.framebufferColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferNoAttachmentsSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.lineWidthGranularity = 1.0f; + s->properties.limits.lineWidthRange[0] = 1.0f; + s->properties.limits.lineWidthRange[1] = 1.0f; + s->properties.limits.maxBoundDescriptorSets = 4; + s->properties.limits.maxClipDistances = 0; + s->properties.limits.maxColorAttachments = 4; + s->properties.limits.maxCombinedClipAndCullDistances = 0; + s->properties.limits.maxComputeSharedMemorySize = 16384; + s->properties.limits.maxComputeWorkGroupCount[0] = 65535; + s->properties.limits.maxComputeWorkGroupCount[1] = 65535; + s->properties.limits.maxComputeWorkGroupCount[2] = 65535; + s->properties.limits.maxComputeWorkGroupInvocations = 128; + s->properties.limits.maxComputeWorkGroupSize[0] = 128; + s->properties.limits.maxComputeWorkGroupSize[1] = 128; + s->properties.limits.maxComputeWorkGroupSize[2] = 64; + s->properties.limits.maxCullDistances = 0; + s->properties.limits.maxDescriptorSetInputAttachments = 4; + s->properties.limits.maxDescriptorSetSampledImages = 96; + s->properties.limits.maxDescriptorSetSamplers = 96; + s->properties.limits.maxDescriptorSetStorageBuffers = 24; + s->properties.limits.maxDescriptorSetStorageBuffersDynamic = 4; + s->properties.limits.maxDescriptorSetStorageImages = 24; + s->properties.limits.maxDescriptorSetUniformBuffers = 72; + s->properties.limits.maxDescriptorSetUniformBuffersDynamic = 8; + s->properties.limits.maxDrawIndexedIndexValue = 16777216; + s->properties.limits.maxDrawIndirectCount = 1; + s->properties.limits.maxFragmentCombinedOutputResources = 4; + s->properties.limits.maxFragmentDualSrcAttachments = 0; + s->properties.limits.maxFragmentInputComponents = 64; + s->properties.limits.maxFragmentOutputAttachments = 4; + s->properties.limits.maxFramebufferHeight = 4096; + s->properties.limits.maxFramebufferLayers = 256; + s->properties.limits.maxFramebufferWidth = 4096; + s->properties.limits.maxGeometryInputComponents = 0; + s->properties.limits.maxGeometryOutputComponents = 0; + s->properties.limits.maxGeometryOutputVertices = 0; + s->properties.limits.maxGeometryShaderInvocations = 0; + s->properties.limits.maxGeometryTotalOutputComponents = 0; + s->properties.limits.maxImageArrayLayers = 256; + s->properties.limits.maxImageDimension1D = 4096; + s->properties.limits.maxImageDimension2D = 4096; + s->properties.limits.maxImageDimension3D = 256; + s->properties.limits.maxImageDimensionCube = 4096; + s->properties.limits.maxInterpolationOffset = 0.0f; + s->properties.limits.maxMemoryAllocationCount = 4096; + s->properties.limits.maxPerStageDescriptorInputAttachments = 4; + s->properties.limits.maxPerStageDescriptorSampledImages = 16; + s->properties.limits.maxPerStageDescriptorSamplers = 16; + s->properties.limits.maxPerStageDescriptorStorageBuffers = 4; + s->properties.limits.maxPerStageDescriptorStorageImages = 4; + s->properties.limits.maxPerStageDescriptorUniformBuffers = 12; + s->properties.limits.maxPerStageResources = 128; + s->properties.limits.maxPushConstantsSize = 128; + s->properties.limits.maxSampleMaskWords = 1; + s->properties.limits.maxSamplerAllocationCount = 4000; + s->properties.limits.maxSamplerAnisotropy = 1; + s->properties.limits.maxSamplerLodBias = 2; + s->properties.limits.maxStorageBufferRange = 134217728; + s->properties.limits.maxTessellationControlPerPatchOutputComponents = 0; + s->properties.limits.maxTessellationControlPerVertexInputComponents = 0; + s->properties.limits.maxTessellationControlPerVertexOutputComponents = 0; + s->properties.limits.maxTessellationControlTotalOutputComponents = 0; + s->properties.limits.maxTessellationEvaluationInputComponents = 0; + s->properties.limits.maxTessellationEvaluationOutputComponents = 0; + s->properties.limits.maxTessellationGenerationLevel = 0; + s->properties.limits.maxTessellationPatchSize = 0; + s->properties.limits.maxTexelBufferElements = 65536; + s->properties.limits.maxTexelGatherOffset = 7; + s->properties.limits.maxTexelOffset = 7; + s->properties.limits.maxUniformBufferRange = 16384; + s->properties.limits.maxVertexInputAttributeOffset = 2047; + s->properties.limits.maxVertexInputAttributes = 16; + s->properties.limits.maxVertexInputBindingStride = 2048; + s->properties.limits.maxVertexInputBindings = 16; + s->properties.limits.maxVertexOutputComponents = 64; + s->properties.limits.maxViewportDimensions[0] = 4096; + s->properties.limits.maxViewportDimensions[1] = 4096; + s->properties.limits.maxViewports = 1; + s->properties.limits.minInterpolationOffset = 0.0f; + s->properties.limits.minMemoryMapAlignment = 64; + s->properties.limits.minStorageBufferOffsetAlignment = 256; + s->properties.limits.minTexelBufferOffsetAlignment = 256; + s->properties.limits.minTexelGatherOffset = -8; + s->properties.limits.minTexelOffset = -8; + s->properties.limits.minUniformBufferOffsetAlignment = 256; + s->properties.limits.mipmapPrecisionBits = 4; + s->properties.limits.nonCoherentAtomSize = 256; + s->properties.limits.pointSizeGranularity = 1.0f; + s->properties.limits.pointSizeRange[0] = 1.0f; + s->properties.limits.pointSizeRange[1] = 1.0f; + s->properties.limits.sampledImageColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageIntegerSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sparseAddressSpaceSize = 0; + s->properties.limits.storageImageSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); + s->properties.limits.subPixelInterpolationOffsetBits = 0; + s->properties.limits.subPixelPrecisionBits = 4; + s->properties.limits.subTexelPrecisionBits = 4; + s->properties.limits.viewportBoundsRange[0] = -8192; + s->properties.limits.viewportBoundsRange[1] = 8192; + s->properties.limits.viewportSubPixelBits = 0; + s->properties.sparseProperties.residencyNonResidentStrict = VK_FALSE; + s->properties.sparseProperties.residencyStandard2DBlockShape = VK_FALSE; + s->properties.sparseProperties.residencyStandard2DMultisampleBlockShape = VK_FALSE; + s->properties.sparseProperties.residencyStandard3DBlockShape = VK_FALSE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *prettify_VkPhysicalDeviceProperties2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity <= 131072); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity <= 131072), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.bufferImageGranularity <= 131072"); + ret = ret && ((131072 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0); + VP_DEBUG_COND_MSG(!((131072 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0), "Unsupported properties condition: (131072 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.discreteQueuePriorities >= 2); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.discreteQueuePriorities >= 2), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.discreteQueuePriorities >= 2"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferDepthSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferNoAttachmentsSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferStencilSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthGranularity <= 1.0"); + ret = ret && (isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)); + VP_DEBUG_COND_MSG(!(isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)), "Unsupported properties condition: isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[0] <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[0] <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthRange[0] <= 1.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[1] >= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[1] >= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthRange[1] >= 1.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxBoundDescriptorSets >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxClipDistances >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxClipDistances >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxClipDistances >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxColorAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCombinedClipAndCullDistances >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCombinedClipAndCullDistances >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxCombinedClipAndCullDistances >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeSharedMemorySize >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeSharedMemorySize >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeSharedMemorySize >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[0] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[0] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[0] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[1] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[1] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[1] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[2] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[2] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[2] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupInvocations >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[0] >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[1] >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[2] >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCullDistances >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCullDistances >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxCullDistances >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetInputAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetInputAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetInputAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 96); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 96), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSampledImages >= 96"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 96); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 96), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSamplers >= 96"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 24); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 24), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffers >= 24"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 24); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 24), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageImages >= 24"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 72); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 72), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffers >= 72"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndexedIndexValue >= 16777216); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndexedIndexValue >= 16777216), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDrawIndexedIndexValue >= 16777216"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndirectCount >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndirectCount >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDrawIndirectCount >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentCombinedOutputResources >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentDualSrcAttachments >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentDualSrcAttachments >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentDualSrcAttachments >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentInputComponents >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentInputComponents >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentInputComponents >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentOutputAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentOutputAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentOutputAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferHeight >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferHeight >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferHeight >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferLayers >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferLayers >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferLayers >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferWidth >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferWidth >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferWidth >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryInputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryInputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryInputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputVertices >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputVertices >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryOutputVertices >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryShaderInvocations >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryShaderInvocations >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryShaderInvocations >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryTotalOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryTotalOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryTotalOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageArrayLayers >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension1D >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension2D >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension3D >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension3D >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension3D >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimensionCube >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxInterpolationOffset >= 0.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxInterpolationOffset >= 0.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxInterpolationOffset >= 0.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxMemoryAllocationCount >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxMemoryAllocationCount >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxMemoryAllocationCount >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorInputAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorInputAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorInputAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSampledImages >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSamplers >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageBuffers >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageImages >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 12); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 12), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorUniformBuffers >= 12"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageResources >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPushConstantsSize >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPushConstantsSize >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPushConstantsSize >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSampleMaskWords >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSampleMaskWords >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSampleMaskWords >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAllocationCount >= 4000); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAllocationCount >= 4000), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerAllocationCount >= 4000"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAnisotropy >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAnisotropy >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerAnisotropy >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 2); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 2), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerLodBias >= 2"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxStorageBufferRange >= 134217728); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxStorageBufferRange >= 134217728), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxStorageBufferRange >= 134217728"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerPatchOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerPatchOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerPatchOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexInputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexInputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerVertexInputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerVertexOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlTotalOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlTotalOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlTotalOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationInputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationInputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationEvaluationInputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationEvaluationOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationGenerationLevel >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationGenerationLevel >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationGenerationLevel >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationPatchSize >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationPatchSize >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationPatchSize >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelBufferElements >= 65536); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelBufferElements >= 65536), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelBufferElements >= 65536"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelGatherOffset >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelGatherOffset >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelGatherOffset >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelOffset >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelOffset >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelOffset >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxUniformBufferRange >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributeOffset >= 2047); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributeOffset >= 2047), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputAttributeOffset >= 2047"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributes >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributes >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputAttributes >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindingStride >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindingStride >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputBindingStride >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindings >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindings >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputBindings >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexOutputComponents >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[0] >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[0] >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewportDimensions[0] >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[1] >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[1] >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewportDimensions[1] >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewports >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewports >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewports >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minInterpolationOffset <= 0.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minInterpolationOffset <= 0.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minInterpolationOffset <= 0.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minMemoryMapAlignment >= 64"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minStorageBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelGatherOffset <= -8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelGatherOffset <= -8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelGatherOffset <= -8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelOffset <= -8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelOffset <= -8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelOffset <= -8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minUniformBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.mipmapPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.nonCoherentAtomSize <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeGranularity <= 1.0"); + ret = ret && (isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)); + VP_DEBUG_COND_MSG(!(isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)), "Unsupported properties condition: isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[0] <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[0] <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeRange[0] <= 1.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[1] >= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[1] >= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeRange[1] >= 1.0"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageDepthSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageIntegerSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageStencilSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sparseAddressSpaceSize >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sparseAddressSpaceSize >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sparseAddressSpaceSize >= 0"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.storageImageSampleCounts contains (VK_SAMPLE_COUNT_1_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelInterpolationOffsetBits >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelInterpolationOffsetBits >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subPixelInterpolationOffsetBits >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subPixelPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subTexelPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[0] <= -8192); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[0] <= -8192), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportBoundsRange[0] <= -8192"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[1] >= 8192); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[1] >= 8192), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportBoundsRange[1] >= 8192"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportSubPixelBits >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportSubPixelBits >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportSubPixelBits >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE"); + } + break; + default: + break; + } + return ret; + }}; static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + p->pNext = static_cast(static_cast(nullptr)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + p->pNext = static_cast(static_cast(nullptr)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, }; -} //namespace vulkan10requirements -namespace vulkan10requirements_roadmap2022 { -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.depthBiasClamp = VK_TRUE; - s->features.depthClamp = VK_TRUE; - s->features.drawIndirectFirstInstance = VK_TRUE; - s->features.fragmentStoresAndAtomics = VK_TRUE; - s->features.fullDrawIndexUint32 = VK_TRUE; - s->features.imageCubeArray = VK_TRUE; - s->features.independentBlend = VK_TRUE; - s->features.occlusionQueryPrecise = VK_TRUE; - s->features.sampleRateShading = VK_TRUE; - s->features.samplerAnisotropy = VK_TRUE; - s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; - s->features.shaderStorageBufferArrayDynamicIndexing = VK_TRUE; - s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; - s->features.shaderStorageImageExtendedFormats = VK_TRUE; - s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.depthBiasClamp == VK_TRUE); - ret = ret && (s->features.depthClamp == VK_TRUE); - ret = ret && (s->features.drawIndirectFirstInstance == VK_TRUE); - ret = ret && (s->features.fragmentStoresAndAtomics == VK_TRUE); - ret = ret && (s->features.fullDrawIndexUint32 == VK_TRUE); - ret = ret && (s->features.imageCubeArray == VK_TRUE); - ret = ret && (s->features.independentBlend == VK_TRUE); - ret = ret && (s->features.occlusionQueryPrecise == VK_TRUE); - ret = ret && (s->features.sampleRateShading == VK_TRUE); - ret = ret && (s->features.samplerAnisotropy == VK_TRUE); - ret = ret && (s->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.shaderStorageImageExtendedFormats == VK_TRUE); - ret = ret && (s->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); - } break; - default: break; - } - return ret; - } +} // namespace vulkan10requirements +} // namespace blocks +} // namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_0 +#endif // VP_LUNARG_minimum_requirements_1_0 + +#ifdef VP_LUNARG_minimum_requirements_1_1 +namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_1 +{ + +static const VkStructureType featureStructTypes[] = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, }; -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - s->properties.limits.bufferImageGranularity = 4096; - s->properties.limits.maxColorAttachments = 7; - s->properties.limits.maxComputeWorkGroupInvocations = 256; - s->properties.limits.maxComputeWorkGroupSize[0] = 256; - s->properties.limits.maxComputeWorkGroupSize[1] = 256; - s->properties.limits.maxComputeWorkGroupSize[2] = 64; - s->properties.limits.maxDescriptorSetSampledImages = 1800; - s->properties.limits.maxDescriptorSetSamplers = 576; - s->properties.limits.maxDescriptorSetStorageBuffers = 96; - s->properties.limits.maxDescriptorSetStorageImages = 144; - s->properties.limits.maxDescriptorSetUniformBuffers = 90; - s->properties.limits.maxFragmentCombinedOutputResources = 16; - s->properties.limits.maxImageArrayLayers = 2048; - s->properties.limits.maxImageDimension1D = 8192; - s->properties.limits.maxImageDimension2D = 8192; - s->properties.limits.maxImageDimensionCube = 8192; - s->properties.limits.maxPerStageDescriptorSampledImages = 200; - s->properties.limits.maxPerStageDescriptorSamplers = 64; - s->properties.limits.maxPerStageDescriptorStorageBuffers = 30; - s->properties.limits.maxPerStageDescriptorStorageImages = 16; - s->properties.limits.maxPerStageDescriptorUniformBuffers = 15; - s->properties.limits.maxPerStageResources = 200; - s->properties.limits.maxSamplerLodBias = 14; - s->properties.limits.maxUniformBufferRange = 65536; - s->properties.limits.mipmapPrecisionBits = 6; - s->properties.limits.standardSampleLocations = VK_TRUE; - s->properties.limits.subTexelPrecisionBits = 8; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->properties.limits.bufferImageGranularity <= 4096); - ret = ret && ((4096 % s->properties.limits.bufferImageGranularity) == 0); - ret = ret && (s->properties.limits.maxColorAttachments >= 7); - ret = ret && (s->properties.limits.maxComputeWorkGroupInvocations >= 256); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[0] >= 256); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[1] >= 256); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[2] >= 64); - ret = ret && (s->properties.limits.maxDescriptorSetSampledImages >= 1800); - ret = ret && (s->properties.limits.maxDescriptorSetSamplers >= 576); - ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffers >= 96); - ret = ret && (s->properties.limits.maxDescriptorSetStorageImages >= 144); - ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffers >= 90); - ret = ret && (s->properties.limits.maxFragmentCombinedOutputResources >= 16); - ret = ret && (s->properties.limits.maxImageArrayLayers >= 2048); - ret = ret && (s->properties.limits.maxImageDimension1D >= 8192); - ret = ret && (s->properties.limits.maxImageDimension2D >= 8192); - ret = ret && (s->properties.limits.maxImageDimensionCube >= 8192); - ret = ret && (s->properties.limits.maxPerStageDescriptorSampledImages >= 200); - ret = ret && (s->properties.limits.maxPerStageDescriptorSamplers >= 64); - ret = ret && (s->properties.limits.maxPerStageDescriptorStorageBuffers >= 30); - ret = ret && (s->properties.limits.maxPerStageDescriptorStorageImages >= 16); - ret = ret && (s->properties.limits.maxPerStageDescriptorUniformBuffers >= 15); - ret = ret && (s->properties.limits.maxPerStageResources >= 200); - ret = ret && (s->properties.limits.maxSamplerLodBias >= 14); - ret = ret && (s->properties.limits.maxUniformBufferRange >= 65536); - ret = ret && (s->properties.limits.mipmapPrecisionBits >= 6); - ret = ret && (s->properties.limits.standardSampleLocations == VK_TRUE); - ret = ret && (s->properties.limits.subTexelPrecisionBits >= 8); - } break; - default: break; - } - return ret; - } +static const VkStructureType propertyStructTypes[] = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, }; +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.robustBufferAccess = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + { + VkPhysicalDeviceMultiviewFeatures *s = static_cast(static_cast(p)); + s->multiview = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + { + VkPhysicalDeviceMultiviewFeatures *prettify_VkPhysicalDeviceMultiviewFeatures = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceMultiviewFeatures->multiview == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceMultiviewFeatures->multiview == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceMultiviewFeatures::multiview == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; + static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceMultiviewFeatures physicalDeviceMultiviewFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, nullptr}; + p->pNext = static_cast(static_cast(&physicalDeviceMultiviewFeatures)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceSubgroupProperties physicalDeviceSubgroupProperties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, nullptr}; + VkPhysicalDeviceMultiviewProperties physicalDeviceMultiviewProperties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, &physicalDeviceSubgroupProperties}; + VkPhysicalDeviceMaintenance3Properties physicalDeviceMaintenance3Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, &physicalDeviceMultiviewProperties}; + p->pNext = static_cast(static_cast(&physicalDeviceMaintenance3Properties)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, }; -} //namespace vulkan10requirements_roadmap2022 -namespace vulkan11requirements { + +namespace blocks +{ +namespace vulkan10requirements +{ + static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceVulkan11Features* s = static_cast(static_cast(p)); - s->multiview = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceVulkan11Features* s = static_cast(static_cast(p)); - ret = ret && (s->multiview == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.robustBufferAccess = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: { - VkPhysicalDeviceVulkan11Properties* s = static_cast(static_cast(p)); - s->maxMultiviewInstanceIndex = 134217727; - s->maxMultiviewViewCount = 6; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: { - VkPhysicalDeviceVulkan11Properties* s = static_cast(static_cast(p)); - ret = ret && (s->maxMultiviewInstanceIndex >= 134217727); - ret = ret && (s->maxMultiviewViewCount >= 6); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *s = static_cast(static_cast(p)); + s->properties.limits.bufferImageGranularity = 131072; + s->properties.limits.discreteQueuePriorities = 2; + s->properties.limits.framebufferColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferNoAttachmentsSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.lineWidthGranularity = 1.0f; + s->properties.limits.lineWidthRange[0] = 1.0f; + s->properties.limits.lineWidthRange[1] = 1.0f; + s->properties.limits.maxBoundDescriptorSets = 4; + s->properties.limits.maxClipDistances = 0; + s->properties.limits.maxColorAttachments = 4; + s->properties.limits.maxCombinedClipAndCullDistances = 0; + s->properties.limits.maxComputeSharedMemorySize = 16384; + s->properties.limits.maxComputeWorkGroupCount[0] = 65535; + s->properties.limits.maxComputeWorkGroupCount[1] = 65535; + s->properties.limits.maxComputeWorkGroupCount[2] = 65535; + s->properties.limits.maxComputeWorkGroupInvocations = 128; + s->properties.limits.maxComputeWorkGroupSize[0] = 128; + s->properties.limits.maxComputeWorkGroupSize[1] = 128; + s->properties.limits.maxComputeWorkGroupSize[2] = 64; + s->properties.limits.maxCullDistances = 0; + s->properties.limits.maxDescriptorSetInputAttachments = 4; + s->properties.limits.maxDescriptorSetSampledImages = 96; + s->properties.limits.maxDescriptorSetSamplers = 96; + s->properties.limits.maxDescriptorSetStorageBuffers = 24; + s->properties.limits.maxDescriptorSetStorageBuffersDynamic = 4; + s->properties.limits.maxDescriptorSetStorageImages = 24; + s->properties.limits.maxDescriptorSetUniformBuffers = 72; + s->properties.limits.maxDescriptorSetUniformBuffersDynamic = 8; + s->properties.limits.maxDrawIndexedIndexValue = 16777216; + s->properties.limits.maxDrawIndirectCount = 1; + s->properties.limits.maxFragmentCombinedOutputResources = 4; + s->properties.limits.maxFragmentDualSrcAttachments = 0; + s->properties.limits.maxFragmentInputComponents = 64; + s->properties.limits.maxFragmentOutputAttachments = 4; + s->properties.limits.maxFramebufferHeight = 4096; + s->properties.limits.maxFramebufferLayers = 256; + s->properties.limits.maxFramebufferWidth = 4096; + s->properties.limits.maxGeometryInputComponents = 0; + s->properties.limits.maxGeometryOutputComponents = 0; + s->properties.limits.maxGeometryOutputVertices = 0; + s->properties.limits.maxGeometryShaderInvocations = 0; + s->properties.limits.maxGeometryTotalOutputComponents = 0; + s->properties.limits.maxImageArrayLayers = 256; + s->properties.limits.maxImageDimension1D = 4096; + s->properties.limits.maxImageDimension2D = 4096; + s->properties.limits.maxImageDimension3D = 256; + s->properties.limits.maxImageDimensionCube = 4096; + s->properties.limits.maxInterpolationOffset = 0.0f; + s->properties.limits.maxMemoryAllocationCount = 4096; + s->properties.limits.maxPerStageDescriptorInputAttachments = 4; + s->properties.limits.maxPerStageDescriptorSampledImages = 16; + s->properties.limits.maxPerStageDescriptorSamplers = 16; + s->properties.limits.maxPerStageDescriptorStorageBuffers = 4; + s->properties.limits.maxPerStageDescriptorStorageImages = 4; + s->properties.limits.maxPerStageDescriptorUniformBuffers = 12; + s->properties.limits.maxPerStageResources = 128; + s->properties.limits.maxPushConstantsSize = 128; + s->properties.limits.maxSampleMaskWords = 1; + s->properties.limits.maxSamplerAllocationCount = 4000; + s->properties.limits.maxSamplerAnisotropy = 1; + s->properties.limits.maxSamplerLodBias = 2; + s->properties.limits.maxStorageBufferRange = 134217728; + s->properties.limits.maxTessellationControlPerPatchOutputComponents = 0; + s->properties.limits.maxTessellationControlPerVertexInputComponents = 0; + s->properties.limits.maxTessellationControlPerVertexOutputComponents = 0; + s->properties.limits.maxTessellationControlTotalOutputComponents = 0; + s->properties.limits.maxTessellationEvaluationInputComponents = 0; + s->properties.limits.maxTessellationEvaluationOutputComponents = 0; + s->properties.limits.maxTessellationGenerationLevel = 0; + s->properties.limits.maxTessellationPatchSize = 0; + s->properties.limits.maxTexelBufferElements = 65536; + s->properties.limits.maxTexelGatherOffset = 7; + s->properties.limits.maxTexelOffset = 7; + s->properties.limits.maxUniformBufferRange = 16384; + s->properties.limits.maxVertexInputAttributeOffset = 2047; + s->properties.limits.maxVertexInputAttributes = 16; + s->properties.limits.maxVertexInputBindingStride = 2048; + s->properties.limits.maxVertexInputBindings = 16; + s->properties.limits.maxVertexOutputComponents = 64; + s->properties.limits.maxViewportDimensions[0] = 4096; + s->properties.limits.maxViewportDimensions[1] = 4096; + s->properties.limits.maxViewports = 1; + s->properties.limits.minInterpolationOffset = 0.0f; + s->properties.limits.minMemoryMapAlignment = 64; + s->properties.limits.minStorageBufferOffsetAlignment = 256; + s->properties.limits.minTexelBufferOffsetAlignment = 256; + s->properties.limits.minTexelGatherOffset = -8; + s->properties.limits.minTexelOffset = -8; + s->properties.limits.minUniformBufferOffsetAlignment = 256; + s->properties.limits.mipmapPrecisionBits = 4; + s->properties.limits.nonCoherentAtomSize = 256; + s->properties.limits.pointSizeGranularity = 1.0f; + s->properties.limits.pointSizeRange[0] = 1.0f; + s->properties.limits.pointSizeRange[1] = 1.0f; + s->properties.limits.sampledImageColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageIntegerSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sparseAddressSpaceSize = 0; + s->properties.limits.storageImageSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); + s->properties.limits.subPixelInterpolationOffsetBits = 0; + s->properties.limits.subPixelPrecisionBits = 4; + s->properties.limits.subTexelPrecisionBits = 4; + s->properties.limits.viewportBoundsRange[0] = -8192; + s->properties.limits.viewportBoundsRange[1] = 8192; + s->properties.limits.viewportSubPixelBits = 0; + s->properties.sparseProperties.residencyNonResidentStrict = VK_FALSE; + s->properties.sparseProperties.residencyStandard2DBlockShape = VK_FALSE; + s->properties.sparseProperties.residencyStandard2DMultisampleBlockShape = VK_FALSE; + s->properties.sparseProperties.residencyStandard3DBlockShape = VK_FALSE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *prettify_VkPhysicalDeviceProperties2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity <= 131072); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity <= 131072), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.bufferImageGranularity <= 131072"); + ret = ret && ((131072 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0); + VP_DEBUG_COND_MSG(!((131072 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0), "Unsupported properties condition: (131072 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.discreteQueuePriorities >= 2); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.discreteQueuePriorities >= 2), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.discreteQueuePriorities >= 2"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferDepthSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferNoAttachmentsSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferStencilSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthGranularity <= 1.0"); + ret = ret && (isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)); + VP_DEBUG_COND_MSG(!(isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)), "Unsupported properties condition: isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[0] <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[0] <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthRange[0] <= 1.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[1] >= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[1] >= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthRange[1] >= 1.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxBoundDescriptorSets >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxClipDistances >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxClipDistances >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxClipDistances >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxColorAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCombinedClipAndCullDistances >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCombinedClipAndCullDistances >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxCombinedClipAndCullDistances >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeSharedMemorySize >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeSharedMemorySize >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeSharedMemorySize >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[0] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[0] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[0] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[1] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[1] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[1] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[2] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[2] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[2] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupInvocations >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[0] >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[1] >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[2] >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCullDistances >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCullDistances >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxCullDistances >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetInputAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetInputAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetInputAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 96); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 96), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSampledImages >= 96"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 96); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 96), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSamplers >= 96"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 24); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 24), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffers >= 24"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 24); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 24), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageImages >= 24"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 72); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 72), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffers >= 72"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndexedIndexValue >= 16777216); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndexedIndexValue >= 16777216), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDrawIndexedIndexValue >= 16777216"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndirectCount >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndirectCount >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDrawIndirectCount >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentCombinedOutputResources >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentDualSrcAttachments >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentDualSrcAttachments >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentDualSrcAttachments >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentInputComponents >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentInputComponents >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentInputComponents >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentOutputAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentOutputAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentOutputAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferHeight >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferHeight >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferHeight >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferLayers >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferLayers >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferLayers >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferWidth >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferWidth >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferWidth >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryInputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryInputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryInputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputVertices >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputVertices >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryOutputVertices >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryShaderInvocations >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryShaderInvocations >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryShaderInvocations >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryTotalOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryTotalOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryTotalOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageArrayLayers >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension1D >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension2D >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension3D >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension3D >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension3D >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimensionCube >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxInterpolationOffset >= 0.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxInterpolationOffset >= 0.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxInterpolationOffset >= 0.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxMemoryAllocationCount >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxMemoryAllocationCount >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxMemoryAllocationCount >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorInputAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorInputAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorInputAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSampledImages >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSamplers >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageBuffers >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageImages >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 12); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 12), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorUniformBuffers >= 12"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageResources >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPushConstantsSize >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPushConstantsSize >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPushConstantsSize >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSampleMaskWords >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSampleMaskWords >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSampleMaskWords >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAllocationCount >= 4000); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAllocationCount >= 4000), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerAllocationCount >= 4000"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAnisotropy >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAnisotropy >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerAnisotropy >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 2); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 2), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerLodBias >= 2"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxStorageBufferRange >= 134217728); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxStorageBufferRange >= 134217728), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxStorageBufferRange >= 134217728"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerPatchOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerPatchOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerPatchOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexInputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexInputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerVertexInputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerVertexOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlTotalOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlTotalOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlTotalOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationInputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationInputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationEvaluationInputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationEvaluationOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationGenerationLevel >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationGenerationLevel >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationGenerationLevel >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationPatchSize >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationPatchSize >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationPatchSize >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelBufferElements >= 65536); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelBufferElements >= 65536), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelBufferElements >= 65536"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelGatherOffset >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelGatherOffset >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelGatherOffset >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelOffset >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelOffset >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelOffset >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxUniformBufferRange >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributeOffset >= 2047); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributeOffset >= 2047), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputAttributeOffset >= 2047"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributes >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributes >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputAttributes >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindingStride >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindingStride >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputBindingStride >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindings >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindings >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputBindings >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexOutputComponents >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[0] >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[0] >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewportDimensions[0] >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[1] >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[1] >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewportDimensions[1] >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewports >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewports >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewports >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minInterpolationOffset <= 0.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minInterpolationOffset <= 0.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minInterpolationOffset <= 0.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minMemoryMapAlignment >= 64"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minStorageBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelGatherOffset <= -8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelGatherOffset <= -8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelGatherOffset <= -8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelOffset <= -8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelOffset <= -8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelOffset <= -8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minUniformBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.mipmapPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.nonCoherentAtomSize <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeGranularity <= 1.0"); + ret = ret && (isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)); + VP_DEBUG_COND_MSG(!(isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)), "Unsupported properties condition: isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[0] <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[0] <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeRange[0] <= 1.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[1] >= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[1] >= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeRange[1] >= 1.0"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageDepthSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageIntegerSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageStencilSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sparseAddressSpaceSize >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sparseAddressSpaceSize >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sparseAddressSpaceSize >= 0"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.storageImageSampleCounts contains (VK_SAMPLE_COUNT_1_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelInterpolationOffsetBits >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelInterpolationOffsetBits >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subPixelInterpolationOffsetBits >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subPixelPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subTexelPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[0] <= -8192); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[0] <= -8192), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportBoundsRange[0] <= -8192"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[1] >= 8192); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[1] >= 8192), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportBoundsRange[1] >= 8192"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportSubPixelBits >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportSubPixelBits >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportSubPixelBits >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE"); + } + break; + default: + break; + } + return ret; + }}; static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceMultiviewFeatures physicalDeviceMultiviewFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, nullptr}; + p->pNext = static_cast(static_cast(&physicalDeviceMultiviewFeatures)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceSubgroupProperties physicalDeviceSubgroupProperties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, nullptr}; + VkPhysicalDeviceMultiviewProperties physicalDeviceMultiviewProperties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, &physicalDeviceSubgroupProperties}; + VkPhysicalDeviceMaintenance3Properties physicalDeviceMaintenance3Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, &physicalDeviceMultiviewProperties}; + p->pNext = static_cast(static_cast(&physicalDeviceMaintenance3Properties)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, }; -} //namespace vulkan11requirements -namespace vulkan11requirements_roadmap2022 { +} // namespace vulkan10requirements +namespace vulkan11requirements_split +{ + static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceVulkan11Features* s = static_cast(static_cast(p)); - s->samplerYcbcrConversion = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceVulkan11Features* s = static_cast(static_cast(p)); - ret = ret && (s->samplerYcbcrConversion == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + { + VkPhysicalDeviceMultiviewFeatures *s = static_cast(static_cast(p)); + s->multiview = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + { + VkPhysicalDeviceMultiviewFeatures *prettify_VkPhysicalDeviceMultiviewFeatures = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceMultiviewFeatures->multiview == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceMultiviewFeatures->multiview == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceMultiviewFeatures::multiview == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: { - VkPhysicalDeviceVulkan11Properties* s = static_cast(static_cast(p)); - s->subgroupSize = 4; - s->subgroupSupportedOperations |= (VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT | VK_SUBGROUP_FEATURE_QUAD_BIT); - s->subgroupSupportedStages |= (VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_FRAGMENT_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: { - VkPhysicalDeviceVulkan11Properties* s = static_cast(static_cast(p)); - ret = ret && (s->subgroupSize >= 4); - ret = ret && ((s->subgroupSize & (s->subgroupSize - 1)) == 0); - ret = ret && (vpCheckFlags(s->subgroupSupportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT | VK_SUBGROUP_FEATURE_QUAD_BIT))); - ret = ret && (vpCheckFlags(s->subgroupSupportedStages, (VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_FRAGMENT_BIT))); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: + { + VkPhysicalDeviceSubgroupProperties *s = static_cast(static_cast(p)); + s->subgroupSize = 1; + s->supportedOperations |= (VK_SUBGROUP_FEATURE_BASIC_BIT); + s->supportedStages |= (VK_SHADER_STAGE_COMPUTE_BIT); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: + { + VkPhysicalDeviceMultiviewProperties *s = static_cast(static_cast(p)); + s->maxMultiviewInstanceIndex = 134217727; + s->maxMultiviewViewCount = 6; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: + { + VkPhysicalDeviceMaintenance3Properties *s = static_cast(static_cast(p)); + s->maxMemoryAllocationSize = 1073741824; + s->maxPerSetDescriptors = 1024; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: + { + VkPhysicalDeviceSubgroupProperties *prettify_VkPhysicalDeviceSubgroupProperties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceSubgroupProperties->subgroupSize >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceSubgroupProperties->subgroupSize >= 1), "Unsupported properties condition: VkPhysicalDeviceSubgroupProperties::subgroupSize >= 1"); + ret = ret && ((prettify_VkPhysicalDeviceSubgroupProperties->subgroupSize & (prettify_VkPhysicalDeviceSubgroupProperties->subgroupSize - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceSubgroupProperties->subgroupSize & (prettify_VkPhysicalDeviceSubgroupProperties->subgroupSize - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceSubgroupProperties->subgroupSize & (prettify_VkPhysicalDeviceSubgroupProperties->subgroupSize - 1)) == 0"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceSubgroupProperties->supportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceSubgroupProperties->supportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT))), "Unsupported properties condition: VkPhysicalDeviceSubgroupProperties::supportedOperations contains (VK_SUBGROUP_FEATURE_BASIC_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceSubgroupProperties->supportedStages, (VK_SHADER_STAGE_COMPUTE_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceSubgroupProperties->supportedStages, (VK_SHADER_STAGE_COMPUTE_BIT))), "Unsupported properties condition: VkPhysicalDeviceSubgroupProperties::supportedStages contains (VK_SHADER_STAGE_COMPUTE_BIT)"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: + { + VkPhysicalDeviceMultiviewProperties *prettify_VkPhysicalDeviceMultiviewProperties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceMultiviewProperties->maxMultiviewInstanceIndex >= 134217727); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceMultiviewProperties->maxMultiviewInstanceIndex >= 134217727), "Unsupported properties condition: VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex >= 134217727"); + ret = ret && (prettify_VkPhysicalDeviceMultiviewProperties->maxMultiviewViewCount >= 6); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceMultiviewProperties->maxMultiviewViewCount >= 6), "Unsupported properties condition: VkPhysicalDeviceMultiviewProperties::maxMultiviewViewCount >= 6"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: + { + VkPhysicalDeviceMaintenance3Properties *prettify_VkPhysicalDeviceMaintenance3Properties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceMaintenance3Properties->maxMemoryAllocationSize >= 1073741824); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceMaintenance3Properties->maxMemoryAllocationSize >= 1073741824), "Unsupported properties condition: VkPhysicalDeviceMaintenance3Properties::maxMemoryAllocationSize >= 1073741824"); + ret = ret && (prettify_VkPhysicalDeviceMaintenance3Properties->maxPerSetDescriptors >= 1024); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceMaintenance3Properties->maxPerSetDescriptors >= 1024), "Unsupported properties condition: VkPhysicalDeviceMaintenance3Properties::maxPerSetDescriptors >= 1024"); + } + break; + default: + break; + } + return ret; + }}; static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceMultiviewFeatures physicalDeviceMultiviewFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, nullptr}; + p->pNext = static_cast(static_cast(&physicalDeviceMultiviewFeatures)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceSubgroupProperties physicalDeviceSubgroupProperties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, nullptr}; + VkPhysicalDeviceMultiviewProperties physicalDeviceMultiviewProperties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, &physicalDeviceSubgroupProperties}; + VkPhysicalDeviceMaintenance3Properties physicalDeviceMaintenance3Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, &physicalDeviceMultiviewProperties}; + p->pNext = static_cast(static_cast(&physicalDeviceMaintenance3Properties)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, }; -} //namespace vulkan11requirements_roadmap2022 -namespace vulkan12requirements { -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - s->hostQueryReset = VK_TRUE; - s->imagelessFramebuffer = VK_TRUE; - s->separateDepthStencilLayouts = VK_TRUE; - s->shaderSubgroupExtendedTypes = VK_TRUE; - s->subgroupBroadcastDynamicId = VK_TRUE; - s->timelineSemaphore = VK_TRUE; - s->uniformBufferStandardLayout = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - ret = ret && (s->hostQueryReset == VK_TRUE); - ret = ret && (s->imagelessFramebuffer == VK_TRUE); - ret = ret && (s->separateDepthStencilLayouts == VK_TRUE); - ret = ret && (s->shaderSubgroupExtendedTypes == VK_TRUE); - ret = ret && (s->subgroupBroadcastDynamicId == VK_TRUE); - ret = ret && (s->timelineSemaphore == VK_TRUE); - ret = ret && (s->uniformBufferStandardLayout == VK_TRUE); - } break; - default: break; - } - return ret; - } +} // namespace vulkan11requirements_split +} // namespace blocks +} // namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_1 +#endif // VP_LUNARG_minimum_requirements_1_1 + +#ifdef VP_LUNARG_minimum_requirements_1_2 +namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_2 +{ + +static const VkStructureType featureStructTypes[] = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, }; -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: { - VkPhysicalDeviceVulkan12Properties* s = static_cast(static_cast(p)); - s->maxTimelineSemaphoreValueDifference = 2147483647; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: { - VkPhysicalDeviceVulkan12Properties* s = static_cast(static_cast(p)); - ret = ret && (s->maxTimelineSemaphoreValueDifference >= 2147483647); - } break; - default: break; - } - return ret; - } +static const VkStructureType propertyStructTypes[] = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, }; +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.robustBufferAccess = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *s = static_cast(static_cast(p)); + s->multiview = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *s = static_cast(static_cast(p)); + s->hostQueryReset = VK_TRUE; + s->imagelessFramebuffer = VK_TRUE; + s->separateDepthStencilLayouts = VK_TRUE; + s->shaderSubgroupExtendedTypes = VK_TRUE; + s->subgroupBroadcastDynamicId = VK_TRUE; + s->timelineSemaphore = VK_TRUE; + s->uniformBufferStandardLayout = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *prettify_VkPhysicalDeviceVulkan11Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::multiview == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *prettify_VkPhysicalDeviceVulkan12Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::hostQueryReset == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::imagelessFramebuffer == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::separateDepthStencilLayouts == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderSubgroupExtendedTypes == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderSubgroupExtendedTypes == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderSubgroupExtendedTypes == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->subgroupBroadcastDynamicId == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->subgroupBroadcastDynamicId == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::subgroupBroadcastDynamicId == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::timelineSemaphore == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::uniformBufferStandardLayout == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; + static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Features)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Properties)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, }; -} //namespace vulkan12requirements -namespace vulkan12requirements_roadmap2022 { + +namespace blocks +{ +namespace vulkan10requirements +{ + static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - s->descriptorBindingPartiallyBound = VK_TRUE; - s->descriptorBindingSampledImageUpdateAfterBind = VK_TRUE; - s->descriptorBindingStorageBufferUpdateAfterBind = VK_TRUE; - s->descriptorBindingStorageImageUpdateAfterBind = VK_TRUE; - s->descriptorBindingStorageTexelBufferUpdateAfterBind = VK_TRUE; - s->descriptorBindingUniformTexelBufferUpdateAfterBind = VK_TRUE; - s->descriptorBindingUpdateUnusedWhilePending = VK_TRUE; - s->descriptorBindingVariableDescriptorCount = VK_TRUE; - s->descriptorIndexing = VK_TRUE; - s->runtimeDescriptorArray = VK_TRUE; - s->samplerMirrorClampToEdge = VK_TRUE; - s->scalarBlockLayout = VK_TRUE; - s->shaderSampledImageArrayNonUniformIndexing = VK_TRUE; - s->shaderStorageBufferArrayNonUniformIndexing = VK_TRUE; - s->shaderStorageImageArrayNonUniformIndexing = VK_TRUE; - s->shaderStorageTexelBufferArrayDynamicIndexing = VK_TRUE; - s->shaderStorageTexelBufferArrayNonUniformIndexing = VK_TRUE; - s->shaderUniformBufferArrayNonUniformIndexing = VK_TRUE; - s->shaderUniformTexelBufferArrayDynamicIndexing = VK_TRUE; - s->shaderUniformTexelBufferArrayNonUniformIndexing = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - ret = ret && (s->descriptorBindingPartiallyBound == VK_TRUE); - ret = ret && (s->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE); - ret = ret && (s->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE); - ret = ret && (s->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE); - ret = ret && (s->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE); - ret = ret && (s->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE); - ret = ret && (s->descriptorBindingUpdateUnusedWhilePending == VK_TRUE); - ret = ret && (s->descriptorBindingVariableDescriptorCount == VK_TRUE); - ret = ret && (s->descriptorIndexing == VK_TRUE); - ret = ret && (s->runtimeDescriptorArray == VK_TRUE); - ret = ret && (s->samplerMirrorClampToEdge == VK_TRUE); - ret = ret && (s->scalarBlockLayout == VK_TRUE); - ret = ret && (s->shaderSampledImageArrayNonUniformIndexing == VK_TRUE); - ret = ret && (s->shaderStorageBufferArrayNonUniformIndexing == VK_TRUE); - ret = ret && (s->shaderStorageImageArrayNonUniformIndexing == VK_TRUE); - ret = ret && (s->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE); - ret = ret && (s->shaderUniformBufferArrayNonUniformIndexing == VK_TRUE); - ret = ret && (s->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.robustBufferAccess = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: { - VkPhysicalDeviceVulkan12Properties* s = static_cast(static_cast(p)); - s->maxDescriptorSetUpdateAfterBindInputAttachments = 7; - s->maxDescriptorSetUpdateAfterBindSampledImages = 500000; - s->maxDescriptorSetUpdateAfterBindSamplers = 500000; - s->maxDescriptorSetUpdateAfterBindStorageBuffers = 500000; - s->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = 4; - s->maxDescriptorSetUpdateAfterBindStorageImages = 500000; - s->maxDescriptorSetUpdateAfterBindUniformBuffers = 72; - s->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = 8; - s->maxPerStageDescriptorUpdateAfterBindInputAttachments = 7; - s->maxPerStageDescriptorUpdateAfterBindSampledImages = 500000; - s->maxPerStageDescriptorUpdateAfterBindSamplers = 500000; - s->maxPerStageDescriptorUpdateAfterBindStorageBuffers = 500000; - s->maxPerStageDescriptorUpdateAfterBindStorageImages = 500000; - s->maxPerStageDescriptorUpdateAfterBindUniformBuffers = 12; - s->maxPerStageUpdateAfterBindResources = 500000; - s->shaderSignedZeroInfNanPreserveFloat16 = VK_TRUE; - s->shaderSignedZeroInfNanPreserveFloat32 = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: { - VkPhysicalDeviceVulkan12Properties* s = static_cast(static_cast(p)); - ret = ret && (s->maxDescriptorSetUpdateAfterBindInputAttachments >= 7); - ret = ret && (s->maxDescriptorSetUpdateAfterBindSampledImages >= 500000); - ret = ret && (s->maxDescriptorSetUpdateAfterBindSamplers >= 500000); - ret = ret && (s->maxDescriptorSetUpdateAfterBindStorageBuffers >= 500000); - ret = ret && (s->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 4); - ret = ret && (s->maxDescriptorSetUpdateAfterBindStorageImages >= 500000); - ret = ret && (s->maxDescriptorSetUpdateAfterBindUniformBuffers >= 72); - ret = ret && (s->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 8); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindInputAttachments >= 7); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindSampledImages >= 500000); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindSamplers >= 500000); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 500000); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindStorageImages >= 500000); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 12); - ret = ret && (s->maxPerStageUpdateAfterBindResources >= 500000); - ret = ret && (vpCheckFlags(s->shaderSignedZeroInfNanPreserveFloat16, VK_TRUE)); - ret = ret && (vpCheckFlags(s->shaderSignedZeroInfNanPreserveFloat32, VK_TRUE)); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *s = static_cast(static_cast(p)); + s->properties.limits.bufferImageGranularity = 131072; + s->properties.limits.discreteQueuePriorities = 2; + s->properties.limits.framebufferColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferNoAttachmentsSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.lineWidthGranularity = 1.0f; + s->properties.limits.lineWidthRange[0] = 1.0f; + s->properties.limits.lineWidthRange[1] = 1.0f; + s->properties.limits.maxBoundDescriptorSets = 4; + s->properties.limits.maxClipDistances = 0; + s->properties.limits.maxColorAttachments = 4; + s->properties.limits.maxCombinedClipAndCullDistances = 0; + s->properties.limits.maxComputeSharedMemorySize = 16384; + s->properties.limits.maxComputeWorkGroupCount[0] = 65535; + s->properties.limits.maxComputeWorkGroupCount[1] = 65535; + s->properties.limits.maxComputeWorkGroupCount[2] = 65535; + s->properties.limits.maxComputeWorkGroupInvocations = 128; + s->properties.limits.maxComputeWorkGroupSize[0] = 128; + s->properties.limits.maxComputeWorkGroupSize[1] = 128; + s->properties.limits.maxComputeWorkGroupSize[2] = 64; + s->properties.limits.maxCullDistances = 0; + s->properties.limits.maxDescriptorSetInputAttachments = 4; + s->properties.limits.maxDescriptorSetSampledImages = 96; + s->properties.limits.maxDescriptorSetSamplers = 96; + s->properties.limits.maxDescriptorSetStorageBuffers = 24; + s->properties.limits.maxDescriptorSetStorageBuffersDynamic = 4; + s->properties.limits.maxDescriptorSetStorageImages = 24; + s->properties.limits.maxDescriptorSetUniformBuffers = 72; + s->properties.limits.maxDescriptorSetUniformBuffersDynamic = 8; + s->properties.limits.maxDrawIndexedIndexValue = 16777216; + s->properties.limits.maxDrawIndirectCount = 1; + s->properties.limits.maxFragmentCombinedOutputResources = 4; + s->properties.limits.maxFragmentDualSrcAttachments = 0; + s->properties.limits.maxFragmentInputComponents = 64; + s->properties.limits.maxFragmentOutputAttachments = 4; + s->properties.limits.maxFramebufferHeight = 4096; + s->properties.limits.maxFramebufferLayers = 256; + s->properties.limits.maxFramebufferWidth = 4096; + s->properties.limits.maxGeometryInputComponents = 0; + s->properties.limits.maxGeometryOutputComponents = 0; + s->properties.limits.maxGeometryOutputVertices = 0; + s->properties.limits.maxGeometryShaderInvocations = 0; + s->properties.limits.maxGeometryTotalOutputComponents = 0; + s->properties.limits.maxImageArrayLayers = 256; + s->properties.limits.maxImageDimension1D = 4096; + s->properties.limits.maxImageDimension2D = 4096; + s->properties.limits.maxImageDimension3D = 256; + s->properties.limits.maxImageDimensionCube = 4096; + s->properties.limits.maxInterpolationOffset = 0.0f; + s->properties.limits.maxMemoryAllocationCount = 4096; + s->properties.limits.maxPerStageDescriptorInputAttachments = 4; + s->properties.limits.maxPerStageDescriptorSampledImages = 16; + s->properties.limits.maxPerStageDescriptorSamplers = 16; + s->properties.limits.maxPerStageDescriptorStorageBuffers = 4; + s->properties.limits.maxPerStageDescriptorStorageImages = 4; + s->properties.limits.maxPerStageDescriptorUniformBuffers = 12; + s->properties.limits.maxPerStageResources = 128; + s->properties.limits.maxPushConstantsSize = 128; + s->properties.limits.maxSampleMaskWords = 1; + s->properties.limits.maxSamplerAllocationCount = 4000; + s->properties.limits.maxSamplerAnisotropy = 1; + s->properties.limits.maxSamplerLodBias = 2; + s->properties.limits.maxStorageBufferRange = 134217728; + s->properties.limits.maxTessellationControlPerPatchOutputComponents = 0; + s->properties.limits.maxTessellationControlPerVertexInputComponents = 0; + s->properties.limits.maxTessellationControlPerVertexOutputComponents = 0; + s->properties.limits.maxTessellationControlTotalOutputComponents = 0; + s->properties.limits.maxTessellationEvaluationInputComponents = 0; + s->properties.limits.maxTessellationEvaluationOutputComponents = 0; + s->properties.limits.maxTessellationGenerationLevel = 0; + s->properties.limits.maxTessellationPatchSize = 0; + s->properties.limits.maxTexelBufferElements = 65536; + s->properties.limits.maxTexelGatherOffset = 7; + s->properties.limits.maxTexelOffset = 7; + s->properties.limits.maxUniformBufferRange = 16384; + s->properties.limits.maxVertexInputAttributeOffset = 2047; + s->properties.limits.maxVertexInputAttributes = 16; + s->properties.limits.maxVertexInputBindingStride = 2048; + s->properties.limits.maxVertexInputBindings = 16; + s->properties.limits.maxVertexOutputComponents = 64; + s->properties.limits.maxViewportDimensions[0] = 4096; + s->properties.limits.maxViewportDimensions[1] = 4096; + s->properties.limits.maxViewports = 1; + s->properties.limits.minInterpolationOffset = 0.0f; + s->properties.limits.minMemoryMapAlignment = 64; + s->properties.limits.minStorageBufferOffsetAlignment = 256; + s->properties.limits.minTexelBufferOffsetAlignment = 256; + s->properties.limits.minTexelGatherOffset = -8; + s->properties.limits.minTexelOffset = -8; + s->properties.limits.minUniformBufferOffsetAlignment = 256; + s->properties.limits.mipmapPrecisionBits = 4; + s->properties.limits.nonCoherentAtomSize = 256; + s->properties.limits.pointSizeGranularity = 1.0f; + s->properties.limits.pointSizeRange[0] = 1.0f; + s->properties.limits.pointSizeRange[1] = 1.0f; + s->properties.limits.sampledImageColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageIntegerSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sparseAddressSpaceSize = 0; + s->properties.limits.storageImageSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); + s->properties.limits.subPixelInterpolationOffsetBits = 0; + s->properties.limits.subPixelPrecisionBits = 4; + s->properties.limits.subTexelPrecisionBits = 4; + s->properties.limits.viewportBoundsRange[0] = -8192; + s->properties.limits.viewportBoundsRange[1] = 8192; + s->properties.limits.viewportSubPixelBits = 0; + s->properties.sparseProperties.residencyNonResidentStrict = VK_FALSE; + s->properties.sparseProperties.residencyStandard2DBlockShape = VK_FALSE; + s->properties.sparseProperties.residencyStandard2DMultisampleBlockShape = VK_FALSE; + s->properties.sparseProperties.residencyStandard3DBlockShape = VK_FALSE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *prettify_VkPhysicalDeviceProperties2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity <= 131072); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity <= 131072), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.bufferImageGranularity <= 131072"); + ret = ret && ((131072 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0); + VP_DEBUG_COND_MSG(!((131072 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0), "Unsupported properties condition: (131072 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.discreteQueuePriorities >= 2); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.discreteQueuePriorities >= 2), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.discreteQueuePriorities >= 2"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferDepthSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferNoAttachmentsSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferStencilSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthGranularity <= 1.0"); + ret = ret && (isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)); + VP_DEBUG_COND_MSG(!(isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)), "Unsupported properties condition: isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[0] <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[0] <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthRange[0] <= 1.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[1] >= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[1] >= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthRange[1] >= 1.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxBoundDescriptorSets >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxClipDistances >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxClipDistances >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxClipDistances >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxColorAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCombinedClipAndCullDistances >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCombinedClipAndCullDistances >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxCombinedClipAndCullDistances >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeSharedMemorySize >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeSharedMemorySize >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeSharedMemorySize >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[0] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[0] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[0] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[1] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[1] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[1] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[2] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[2] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[2] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupInvocations >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[0] >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[1] >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[2] >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCullDistances >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCullDistances >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxCullDistances >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetInputAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetInputAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetInputAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 96); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 96), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSampledImages >= 96"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 96); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 96), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSamplers >= 96"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 24); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 24), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffers >= 24"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 24); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 24), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageImages >= 24"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 72); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 72), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffers >= 72"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndexedIndexValue >= 16777216); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndexedIndexValue >= 16777216), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDrawIndexedIndexValue >= 16777216"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndirectCount >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndirectCount >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDrawIndirectCount >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentCombinedOutputResources >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentDualSrcAttachments >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentDualSrcAttachments >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentDualSrcAttachments >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentInputComponents >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentInputComponents >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentInputComponents >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentOutputAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentOutputAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentOutputAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferHeight >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferHeight >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferHeight >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferLayers >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferLayers >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferLayers >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferWidth >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferWidth >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferWidth >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryInputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryInputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryInputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputVertices >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputVertices >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryOutputVertices >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryShaderInvocations >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryShaderInvocations >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryShaderInvocations >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryTotalOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryTotalOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryTotalOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageArrayLayers >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension1D >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension2D >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension3D >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension3D >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension3D >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimensionCube >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxInterpolationOffset >= 0.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxInterpolationOffset >= 0.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxInterpolationOffset >= 0.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxMemoryAllocationCount >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxMemoryAllocationCount >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxMemoryAllocationCount >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorInputAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorInputAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorInputAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSampledImages >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSamplers >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageBuffers >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageImages >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 12); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 12), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorUniformBuffers >= 12"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageResources >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPushConstantsSize >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPushConstantsSize >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPushConstantsSize >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSampleMaskWords >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSampleMaskWords >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSampleMaskWords >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAllocationCount >= 4000); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAllocationCount >= 4000), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerAllocationCount >= 4000"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAnisotropy >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAnisotropy >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerAnisotropy >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 2); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 2), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerLodBias >= 2"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxStorageBufferRange >= 134217728); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxStorageBufferRange >= 134217728), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxStorageBufferRange >= 134217728"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerPatchOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerPatchOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerPatchOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexInputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexInputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerVertexInputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerVertexOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlTotalOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlTotalOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlTotalOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationInputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationInputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationEvaluationInputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationEvaluationOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationGenerationLevel >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationGenerationLevel >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationGenerationLevel >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationPatchSize >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationPatchSize >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationPatchSize >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelBufferElements >= 65536); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelBufferElements >= 65536), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelBufferElements >= 65536"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelGatherOffset >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelGatherOffset >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelGatherOffset >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelOffset >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelOffset >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelOffset >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxUniformBufferRange >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributeOffset >= 2047); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributeOffset >= 2047), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputAttributeOffset >= 2047"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributes >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributes >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputAttributes >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindingStride >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindingStride >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputBindingStride >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindings >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindings >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputBindings >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexOutputComponents >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[0] >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[0] >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewportDimensions[0] >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[1] >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[1] >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewportDimensions[1] >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewports >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewports >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewports >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minInterpolationOffset <= 0.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minInterpolationOffset <= 0.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minInterpolationOffset <= 0.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minMemoryMapAlignment >= 64"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minStorageBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelGatherOffset <= -8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelGatherOffset <= -8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelGatherOffset <= -8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelOffset <= -8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelOffset <= -8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelOffset <= -8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minUniformBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.mipmapPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.nonCoherentAtomSize <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeGranularity <= 1.0"); + ret = ret && (isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)); + VP_DEBUG_COND_MSG(!(isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)), "Unsupported properties condition: isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[0] <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[0] <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeRange[0] <= 1.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[1] >= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[1] >= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeRange[1] >= 1.0"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageDepthSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageIntegerSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageStencilSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sparseAddressSpaceSize >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sparseAddressSpaceSize >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sparseAddressSpaceSize >= 0"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.storageImageSampleCounts contains (VK_SAMPLE_COUNT_1_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelInterpolationOffsetBits >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelInterpolationOffsetBits >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subPixelInterpolationOffsetBits >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subPixelPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subTexelPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[0] <= -8192); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[0] <= -8192), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportBoundsRange[0] <= -8192"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[1] >= 8192); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[1] >= 8192), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportBoundsRange[1] >= 8192"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportSubPixelBits >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportSubPixelBits >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportSubPixelBits >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE"); + } + break; + default: + break; + } + return ret; + }}; static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Features)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Properties)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, }; -} //namespace vulkan12requirements_roadmap2022 -namespace vulkan13requirements { +} // namespace vulkan10requirements +namespace vulkan11requirements +{ + static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - s->bufferDeviceAddress = VK_TRUE; - s->vulkanMemoryModel = VK_TRUE; - s->vulkanMemoryModelDeviceScope = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: { - VkPhysicalDeviceVulkan13Features* s = static_cast(static_cast(p)); - s->computeFullSubgroups = VK_TRUE; - s->dynamicRendering = VK_TRUE; - s->inlineUniformBlock = VK_TRUE; - s->maintenance4 = VK_TRUE; - s->pipelineCreationCacheControl = VK_TRUE; - s->robustImageAccess = VK_TRUE; - s->shaderDemoteToHelperInvocation = VK_TRUE; - s->shaderIntegerDotProduct = VK_TRUE; - s->shaderTerminateInvocation = VK_TRUE; - s->shaderZeroInitializeWorkgroupMemory = VK_TRUE; - s->subgroupSizeControl = VK_TRUE; - s->synchronization2 = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - ret = ret && (s->bufferDeviceAddress == VK_TRUE); - ret = ret && (s->vulkanMemoryModel == VK_TRUE); - ret = ret && (s->vulkanMemoryModelDeviceScope == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: { - VkPhysicalDeviceVulkan13Features* s = static_cast(static_cast(p)); - ret = ret && (s->computeFullSubgroups == VK_TRUE); - ret = ret && (s->dynamicRendering == VK_TRUE); - ret = ret && (s->inlineUniformBlock == VK_TRUE); - ret = ret && (s->maintenance4 == VK_TRUE); - ret = ret && (s->pipelineCreationCacheControl == VK_TRUE); - ret = ret && (s->robustImageAccess == VK_TRUE); - ret = ret && (s->shaderDemoteToHelperInvocation == VK_TRUE); - ret = ret && (s->shaderIntegerDotProduct == VK_TRUE); - ret = ret && (s->shaderTerminateInvocation == VK_TRUE); - ret = ret && (s->shaderZeroInitializeWorkgroupMemory == VK_TRUE); - ret = ret && (s->subgroupSizeControl == VK_TRUE); - ret = ret && (s->synchronization2 == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *s = static_cast(static_cast(p)); + s->multiview = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *prettify_VkPhysicalDeviceVulkan11Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::multiview == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: { - VkPhysicalDeviceVulkan13Properties* s = static_cast(static_cast(p)); - s->maxBufferSize = 1073741824; - s->maxDescriptorSetInlineUniformBlocks = 4; - s->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = 4; - s->maxInlineUniformBlockSize = 256; - s->maxInlineUniformTotalSize = 256; - s->maxPerStageDescriptorInlineUniformBlocks = 4; - s->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = 4; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: { - VkPhysicalDeviceVulkan13Properties* s = static_cast(static_cast(p)); - ret = ret && (s->maxBufferSize >= 1073741824); - ret = ret && (s->maxDescriptorSetInlineUniformBlocks >= 4); - ret = ret && (s->maxDescriptorSetUpdateAfterBindInlineUniformBlocks >= 4); - ret = ret && (s->maxInlineUniformBlockSize >= 256); - ret = ret && (s->maxInlineUniformTotalSize >= 256); - ret = ret && (s->maxPerStageDescriptorInlineUniformBlocks >= 4); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks >= 4); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + { + VkPhysicalDeviceVulkan11Properties *s = static_cast(static_cast(p)); + s->maxMemoryAllocationSize = 1073741824; + s->maxMultiviewInstanceIndex = 134217727; + s->maxMultiviewViewCount = 6; + s->maxPerSetDescriptors = 1024; + s->subgroupSize = 1; + s->subgroupSupportedOperations |= (VK_SUBGROUP_FEATURE_BASIC_BIT); + s->subgroupSupportedStages |= (VK_SHADER_STAGE_COMPUTE_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + { + VkPhysicalDeviceVulkan11Properties *prettify_VkPhysicalDeviceVulkan11Properties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->maxMemoryAllocationSize >= 1073741824); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->maxMemoryAllocationSize >= 1073741824), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::maxMemoryAllocationSize >= 1073741824"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewInstanceIndex >= 134217727); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewInstanceIndex >= 134217727), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::maxMultiviewInstanceIndex >= 134217727"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewViewCount >= 6); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewViewCount >= 6), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::maxMultiviewViewCount >= 6"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->maxPerSetDescriptors >= 1024); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->maxPerSetDescriptors >= 1024), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::maxPerSetDescriptors >= 1024"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize >= 1), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::subgroupSize >= 1"); + ret = ret && ((prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize & (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize & (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize & (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize - 1)) == 0"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::subgroupSupportedOperations contains (VK_SUBGROUP_FEATURE_BASIC_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedStages, (VK_SHADER_STAGE_COMPUTE_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedStages, (VK_SHADER_STAGE_COMPUTE_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::subgroupSupportedStages contains (VK_SHADER_STAGE_COMPUTE_BIT)"); + } + break; + default: + break; + } + return ret; + }}; static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Features)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Properties)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, }; -} //namespace vulkan13requirements -namespace vulkan13requirements_roadmap2022 { -static const VkExtensionProperties deviceExtensions[] = { - VkExtensionProperties{ VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME, 1 }, -}; +} // namespace vulkan11requirements +namespace vulkan12requirements +{ static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: { - VkPhysicalDeviceVulkan13Features* s = static_cast(static_cast(p)); - s->descriptorBindingInlineUniformBlockUpdateAfterBind = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: { - VkPhysicalDeviceVulkan13Features* s = static_cast(static_cast(p)); - ret = ret && (s->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *s = static_cast(static_cast(p)); + s->hostQueryReset = VK_TRUE; + s->imagelessFramebuffer = VK_TRUE; + s->separateDepthStencilLayouts = VK_TRUE; + s->shaderSubgroupExtendedTypes = VK_TRUE; + s->subgroupBroadcastDynamicId = VK_TRUE; + s->timelineSemaphore = VK_TRUE; + s->uniformBufferStandardLayout = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *prettify_VkPhysicalDeviceVulkan12Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::hostQueryReset == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::imagelessFramebuffer == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::separateDepthStencilLayouts == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderSubgroupExtendedTypes == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderSubgroupExtendedTypes == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderSubgroupExtendedTypes == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->subgroupBroadcastDynamicId == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->subgroupBroadcastDynamicId == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::subgroupBroadcastDynamicId == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::timelineSemaphore == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::uniformBufferStandardLayout == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } -}; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + { + VkPhysicalDeviceVulkan12Properties *s = static_cast(static_cast(p)); + s->filterMinmaxImageComponentMapping = VK_FALSE; + s->filterMinmaxSingleComponentFormats = VK_FALSE; + s->framebufferIntegerColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); + s->independentResolve = VK_FALSE; + s->independentResolveNone = VK_FALSE; + s->maxDescriptorSetUpdateAfterBindInputAttachments = 0; + s->maxDescriptorSetUpdateAfterBindSampledImages = 0; + s->maxDescriptorSetUpdateAfterBindSamplers = 0; + s->maxDescriptorSetUpdateAfterBindStorageBuffers = 0; + s->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = 0; + s->maxDescriptorSetUpdateAfterBindStorageImages = 0; + s->maxDescriptorSetUpdateAfterBindUniformBuffers = 0; + s->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = 0; + s->maxPerStageDescriptorUpdateAfterBindInputAttachments = 0; + s->maxPerStageDescriptorUpdateAfterBindSampledImages = 0; + s->maxPerStageDescriptorUpdateAfterBindSamplers = 0; + s->maxPerStageDescriptorUpdateAfterBindStorageBuffers = 0; + s->maxPerStageDescriptorUpdateAfterBindStorageImages = 0; + s->maxPerStageDescriptorUpdateAfterBindUniformBuffers = 0; + s->maxPerStageUpdateAfterBindResources = 0; + s->maxTimelineSemaphoreValueDifference = 2147483647; + s->maxUpdateAfterBindDescriptorsInAllPools = 0; + s->quadDivergentImplicitLod = VK_FALSE; + s->robustBufferAccessUpdateAfterBind = VK_FALSE; + s->shaderDenormFlushToZeroFloat16 = VK_FALSE; + s->shaderDenormFlushToZeroFloat32 = VK_FALSE; + s->shaderDenormFlushToZeroFloat64 = VK_FALSE; + s->shaderDenormPreserveFloat16 = VK_FALSE; + s->shaderDenormPreserveFloat32 = VK_FALSE; + s->shaderDenormPreserveFloat64 = VK_FALSE; + s->shaderInputAttachmentArrayNonUniformIndexingNative = VK_FALSE; + s->shaderRoundingModeRTEFloat16 = VK_FALSE; + s->shaderRoundingModeRTEFloat32 = VK_FALSE; + s->shaderRoundingModeRTEFloat64 = VK_FALSE; + s->shaderRoundingModeRTZFloat16 = VK_FALSE; + s->shaderRoundingModeRTZFloat32 = VK_FALSE; + s->shaderRoundingModeRTZFloat64 = VK_FALSE; + s->shaderSampledImageArrayNonUniformIndexingNative = VK_FALSE; + s->shaderSignedZeroInfNanPreserveFloat16 = VK_FALSE; + s->shaderSignedZeroInfNanPreserveFloat32 = VK_FALSE; + s->shaderSignedZeroInfNanPreserveFloat64 = VK_FALSE; + s->shaderStorageBufferArrayNonUniformIndexingNative = VK_FALSE; + s->shaderStorageImageArrayNonUniformIndexingNative = VK_FALSE; + s->shaderUniformBufferArrayNonUniformIndexingNative = VK_FALSE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + { + VkPhysicalDeviceVulkan12Properties *prettify_VkPhysicalDeviceVulkan12Properties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->filterMinmaxImageComponentMapping >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->filterMinmaxImageComponentMapping >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::filterMinmaxImageComponentMapping >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->filterMinmaxSingleComponentFormats >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->filterMinmaxSingleComponentFormats >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::filterMinmaxSingleComponentFormats >= VK_FALSE"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan12Properties->framebufferIntegerColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan12Properties->framebufferIntegerColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::framebufferIntegerColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->independentResolve >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->independentResolve >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::independentResolve >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->independentResolveNone >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->independentResolveNone >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::independentResolveNone >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindInputAttachments >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindInputAttachments >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindInputAttachments >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSampledImages >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSampledImages >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindSampledImages >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSamplers >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSamplers >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindSamplers >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffers >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffers >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindStorageBuffers >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageImages >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageImages >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindStorageImages >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffers >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffers >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindUniformBuffers >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindInputAttachments >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindInputAttachments >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindInputAttachments >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSampledImages >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSampledImages >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindSampledImages >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSamplers >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSamplers >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindSamplers >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageImages >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageImages >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindStorageImages >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageUpdateAfterBindResources >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageUpdateAfterBindResources >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageUpdateAfterBindResources >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxTimelineSemaphoreValueDifference >= 2147483647); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxTimelineSemaphoreValueDifference >= 2147483647), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxTimelineSemaphoreValueDifference >= 2147483647"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxUpdateAfterBindDescriptorsInAllPools >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxUpdateAfterBindDescriptorsInAllPools >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxUpdateAfterBindDescriptorsInAllPools >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->quadDivergentImplicitLod >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->quadDivergentImplicitLod >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::quadDivergentImplicitLod >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->robustBufferAccessUpdateAfterBind >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->robustBufferAccessUpdateAfterBind >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::robustBufferAccessUpdateAfterBind >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormFlushToZeroFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormFlushToZeroFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormFlushToZeroFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormPreserveFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormPreserveFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormPreserveFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderInputAttachmentArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderInputAttachmentArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderInputAttachmentArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTEFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTEFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTEFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTZFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTZFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTZFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderSampledImageArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderSampledImageArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderSampledImageArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderSignedZeroInfNanPreserveFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderSignedZeroInfNanPreserveFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderSignedZeroInfNanPreserveFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderStorageBufferArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderStorageBufferArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderStorageBufferArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderStorageImageArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderStorageImageArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderStorageImageArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderUniformBufferArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderUniformBufferArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderUniformBufferArrayNonUniformIndexingNative >= VK_FALSE"); + } + break; + default: + break; + } + return ret; + }}; static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Features)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Properties)); + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, }; -} //namespace vulkan13requirements_roadmap2022 -} // namespace VP_KHR_ROADMAP_2022 -#endif // VP_KHR_roadmap_2022 +} // namespace vulkan12requirements +} // namespace blocks +} // namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_2 +#endif // VP_LUNARG_minimum_requirements_1_2 -#ifdef VP_KHR_roadmap_2024 -namespace VP_KHR_ROADMAP_2024 { +#ifdef VP_LUNARG_minimum_requirements_1_3 +namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_3 +{ static const VkStructureType featureStructTypes[] = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, @@ -8080,6403 +28475,6611 @@ static const VkStructureType featureStructTypes[] = { static const VkStructureType propertyStructTypes[] = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, }; -static const VkExtensionProperties deviceExtensions[] = { - VkExtensionProperties{ VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_MAINTENANCE_5_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_MAP_MEMORY_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, 1 }, +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.robustBufferAccess = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *s = static_cast(static_cast(p)); + s->multiview = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *s = static_cast(static_cast(p)); + s->bufferDeviceAddress = VK_TRUE; + s->hostQueryReset = VK_TRUE; + s->imagelessFramebuffer = VK_TRUE; + s->separateDepthStencilLayouts = VK_TRUE; + s->shaderSubgroupExtendedTypes = VK_TRUE; + s->subgroupBroadcastDynamicId = VK_TRUE; + s->timelineSemaphore = VK_TRUE; + s->uniformBufferStandardLayout = VK_TRUE; + s->vulkanMemoryModel = VK_TRUE; + s->vulkanMemoryModelDeviceScope = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + { + VkPhysicalDeviceVulkan13Features *s = static_cast(static_cast(p)); + s->computeFullSubgroups = VK_TRUE; + s->dynamicRendering = VK_TRUE; + s->inlineUniformBlock = VK_TRUE; + s->maintenance4 = VK_TRUE; + s->pipelineCreationCacheControl = VK_TRUE; + s->robustImageAccess = VK_TRUE; + s->shaderDemoteToHelperInvocation = VK_TRUE; + s->shaderIntegerDotProduct = VK_TRUE; + s->shaderTerminateInvocation = VK_TRUE; + s->shaderZeroInitializeWorkgroupMemory = VK_TRUE; + s->subgroupSizeControl = VK_TRUE; + s->synchronization2 = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *prettify_VkPhysicalDeviceVulkan11Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::multiview == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *prettify_VkPhysicalDeviceVulkan12Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->bufferDeviceAddress == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->bufferDeviceAddress == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::bufferDeviceAddress == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::hostQueryReset == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::imagelessFramebuffer == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::separateDepthStencilLayouts == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderSubgroupExtendedTypes == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderSubgroupExtendedTypes == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderSubgroupExtendedTypes == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->subgroupBroadcastDynamicId == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->subgroupBroadcastDynamicId == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::subgroupBroadcastDynamicId == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::timelineSemaphore == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::uniformBufferStandardLayout == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModel == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModel == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::vulkanMemoryModel == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModelDeviceScope == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModelDeviceScope == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::vulkanMemoryModelDeviceScope == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + { + VkPhysicalDeviceVulkan13Features *prettify_VkPhysicalDeviceVulkan13Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->computeFullSubgroups == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->computeFullSubgroups == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::computeFullSubgroups == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->dynamicRendering == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->dynamicRendering == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::dynamicRendering == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->inlineUniformBlock == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->inlineUniformBlock == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::inlineUniformBlock == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->maintenance4 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->maintenance4 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::maintenance4 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->pipelineCreationCacheControl == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->pipelineCreationCacheControl == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::pipelineCreationCacheControl == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->robustImageAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->robustImageAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::robustImageAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderDemoteToHelperInvocation == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderDemoteToHelperInvocation == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderDemoteToHelperInvocation == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderIntegerDotProduct == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderIntegerDotProduct == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderIntegerDotProduct == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderTerminateInvocation == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderTerminateInvocation == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderTerminateInvocation == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderZeroInitializeWorkgroupMemory == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderZeroInitializeWorkgroupMemory == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderZeroInitializeWorkgroupMemory == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->subgroupSizeControl == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->subgroupSizeControl == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::subgroupSizeControl == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->synchronization2 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->synchronization2 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::synchronization2 == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); + }, +}; + +namespace blocks +{ +namespace vulkan10requirements +{ + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *s = static_cast(static_cast(p)); + s->features.robustBufferAccess = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: + { + VkPhysicalDeviceFeatures2KHR *prettify_VkPhysicalDeviceFeatures2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceFeatures2KHR->features.robustBufferAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceFeatures2KHR::features.robustBufferAccess == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *s = static_cast(static_cast(p)); + s->properties.limits.bufferImageGranularity = 131072; + s->properties.limits.discreteQueuePriorities = 2; + s->properties.limits.framebufferColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferNoAttachmentsSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.framebufferStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.lineWidthGranularity = 1.0f; + s->properties.limits.lineWidthRange[0] = 1.0f; + s->properties.limits.lineWidthRange[1] = 1.0f; + s->properties.limits.maxBoundDescriptorSets = 4; + s->properties.limits.maxClipDistances = 0; + s->properties.limits.maxColorAttachments = 4; + s->properties.limits.maxCombinedClipAndCullDistances = 0; + s->properties.limits.maxComputeSharedMemorySize = 16384; + s->properties.limits.maxComputeWorkGroupCount[0] = 65535; + s->properties.limits.maxComputeWorkGroupCount[1] = 65535; + s->properties.limits.maxComputeWorkGroupCount[2] = 65535; + s->properties.limits.maxComputeWorkGroupInvocations = 128; + s->properties.limits.maxComputeWorkGroupSize[0] = 128; + s->properties.limits.maxComputeWorkGroupSize[1] = 128; + s->properties.limits.maxComputeWorkGroupSize[2] = 64; + s->properties.limits.maxCullDistances = 0; + s->properties.limits.maxDescriptorSetInputAttachments = 4; + s->properties.limits.maxDescriptorSetSampledImages = 96; + s->properties.limits.maxDescriptorSetSamplers = 96; + s->properties.limits.maxDescriptorSetStorageBuffers = 24; + s->properties.limits.maxDescriptorSetStorageBuffersDynamic = 4; + s->properties.limits.maxDescriptorSetStorageImages = 24; + s->properties.limits.maxDescriptorSetUniformBuffers = 72; + s->properties.limits.maxDescriptorSetUniformBuffersDynamic = 8; + s->properties.limits.maxDrawIndexedIndexValue = 16777216; + s->properties.limits.maxDrawIndirectCount = 1; + s->properties.limits.maxFragmentCombinedOutputResources = 4; + s->properties.limits.maxFragmentDualSrcAttachments = 0; + s->properties.limits.maxFragmentInputComponents = 64; + s->properties.limits.maxFragmentOutputAttachments = 4; + s->properties.limits.maxFramebufferHeight = 4096; + s->properties.limits.maxFramebufferLayers = 256; + s->properties.limits.maxFramebufferWidth = 4096; + s->properties.limits.maxGeometryInputComponents = 0; + s->properties.limits.maxGeometryOutputComponents = 0; + s->properties.limits.maxGeometryOutputVertices = 0; + s->properties.limits.maxGeometryShaderInvocations = 0; + s->properties.limits.maxGeometryTotalOutputComponents = 0; + s->properties.limits.maxImageArrayLayers = 256; + s->properties.limits.maxImageDimension1D = 4096; + s->properties.limits.maxImageDimension2D = 4096; + s->properties.limits.maxImageDimension3D = 256; + s->properties.limits.maxImageDimensionCube = 4096; + s->properties.limits.maxInterpolationOffset = 0.0f; + s->properties.limits.maxMemoryAllocationCount = 4096; + s->properties.limits.maxPerStageDescriptorInputAttachments = 4; + s->properties.limits.maxPerStageDescriptorSampledImages = 16; + s->properties.limits.maxPerStageDescriptorSamplers = 16; + s->properties.limits.maxPerStageDescriptorStorageBuffers = 4; + s->properties.limits.maxPerStageDescriptorStorageImages = 4; + s->properties.limits.maxPerStageDescriptorUniformBuffers = 12; + s->properties.limits.maxPerStageResources = 128; + s->properties.limits.maxPushConstantsSize = 128; + s->properties.limits.maxSampleMaskWords = 1; + s->properties.limits.maxSamplerAllocationCount = 4000; + s->properties.limits.maxSamplerAnisotropy = 1; + s->properties.limits.maxSamplerLodBias = 2; + s->properties.limits.maxStorageBufferRange = 134217728; + s->properties.limits.maxTessellationControlPerPatchOutputComponents = 0; + s->properties.limits.maxTessellationControlPerVertexInputComponents = 0; + s->properties.limits.maxTessellationControlPerVertexOutputComponents = 0; + s->properties.limits.maxTessellationControlTotalOutputComponents = 0; + s->properties.limits.maxTessellationEvaluationInputComponents = 0; + s->properties.limits.maxTessellationEvaluationOutputComponents = 0; + s->properties.limits.maxTessellationGenerationLevel = 0; + s->properties.limits.maxTessellationPatchSize = 0; + s->properties.limits.maxTexelBufferElements = 65536; + s->properties.limits.maxTexelGatherOffset = 7; + s->properties.limits.maxTexelOffset = 7; + s->properties.limits.maxUniformBufferRange = 16384; + s->properties.limits.maxVertexInputAttributeOffset = 2047; + s->properties.limits.maxVertexInputAttributes = 16; + s->properties.limits.maxVertexInputBindingStride = 2048; + s->properties.limits.maxVertexInputBindings = 16; + s->properties.limits.maxVertexOutputComponents = 64; + s->properties.limits.maxViewportDimensions[0] = 4096; + s->properties.limits.maxViewportDimensions[1] = 4096; + s->properties.limits.maxViewports = 1; + s->properties.limits.minInterpolationOffset = 0.0f; + s->properties.limits.minMemoryMapAlignment = 64; + s->properties.limits.minStorageBufferOffsetAlignment = 256; + s->properties.limits.minTexelBufferOffsetAlignment = 256; + s->properties.limits.minTexelGatherOffset = -8; + s->properties.limits.minTexelOffset = -8; + s->properties.limits.minUniformBufferOffsetAlignment = 256; + s->properties.limits.mipmapPrecisionBits = 4; + s->properties.limits.nonCoherentAtomSize = 256; + s->properties.limits.pointSizeGranularity = 1.0f; + s->properties.limits.pointSizeRange[0] = 1.0f; + s->properties.limits.pointSizeRange[1] = 1.0f; + s->properties.limits.sampledImageColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageIntegerSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sampledImageStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + s->properties.limits.sparseAddressSpaceSize = 0; + s->properties.limits.storageImageSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); + s->properties.limits.subPixelInterpolationOffsetBits = 0; + s->properties.limits.subPixelPrecisionBits = 4; + s->properties.limits.subTexelPrecisionBits = 4; + s->properties.limits.viewportBoundsRange[0] = -8192; + s->properties.limits.viewportBoundsRange[1] = 8192; + s->properties.limits.viewportSubPixelBits = 0; + s->properties.sparseProperties.residencyNonResidentStrict = VK_FALSE; + s->properties.sparseProperties.residencyStandard2DBlockShape = VK_FALSE; + s->properties.sparseProperties.residencyStandard2DMultisampleBlockShape = VK_FALSE; + s->properties.sparseProperties.residencyStandard3DBlockShape = VK_FALSE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: + { + VkPhysicalDeviceProperties2KHR *prettify_VkPhysicalDeviceProperties2KHR = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity <= 131072); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity <= 131072), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.bufferImageGranularity <= 131072"); + ret = ret && ((131072 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0); + VP_DEBUG_COND_MSG(!((131072 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0), "Unsupported properties condition: (131072 % prettify_VkPhysicalDeviceProperties2KHR->properties.limits.bufferImageGranularity) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.discreteQueuePriorities >= 2); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.discreteQueuePriorities >= 2), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.discreteQueuePriorities >= 2"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferDepthSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferNoAttachmentsSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.framebufferStencilSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthGranularity <= 1.0"); + ret = ret && (isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)); + VP_DEBUG_COND_MSG(!(isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)), "Unsupported properties condition: isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthGranularity)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[0] <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[0] <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthRange[0] <= 1.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[1] >= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.lineWidthRange[1] >= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.lineWidthRange[1] >= 1.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxBoundDescriptorSets >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxBoundDescriptorSets >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxClipDistances >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxClipDistances >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxClipDistances >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxColorAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxColorAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCombinedClipAndCullDistances >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCombinedClipAndCullDistances >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxCombinedClipAndCullDistances >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeSharedMemorySize >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeSharedMemorySize >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeSharedMemorySize >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[0] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[0] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[0] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[1] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[1] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[1] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[2] >= 65535); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupCount[2] >= 65535), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupCount[2] >= 65535"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupInvocations >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupInvocations >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[0] >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[0] >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[1] >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[1] >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxComputeWorkGroupSize[2] >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxComputeWorkGroupSize[2] >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCullDistances >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxCullDistances >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxCullDistances >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetInputAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetInputAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetInputAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 96); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSampledImages >= 96), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSampledImages >= 96"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 96); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetSamplers >= 96), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetSamplers >= 96"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 24); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffers >= 24), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffers >= 24"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 24); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetStorageImages >= 24), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetStorageImages >= 24"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 72); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffers >= 72), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffers >= 72"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndexedIndexValue >= 16777216); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndexedIndexValue >= 16777216), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDrawIndexedIndexValue >= 16777216"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndirectCount >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxDrawIndirectCount >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxDrawIndirectCount >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentCombinedOutputResources >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentCombinedOutputResources >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentDualSrcAttachments >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentDualSrcAttachments >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentDualSrcAttachments >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentInputComponents >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentInputComponents >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentInputComponents >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentOutputAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFragmentOutputAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFragmentOutputAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferHeight >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferHeight >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferHeight >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferLayers >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferLayers >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferLayers >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferWidth >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxFramebufferWidth >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxFramebufferWidth >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryInputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryInputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryInputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputVertices >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryOutputVertices >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryOutputVertices >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryShaderInvocations >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryShaderInvocations >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryShaderInvocations >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryTotalOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxGeometryTotalOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxGeometryTotalOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageArrayLayers >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageArrayLayers >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension1D >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension1D >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension2D >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension2D >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension3D >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimension3D >= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimension3D >= 256"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxImageDimensionCube >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxImageDimensionCube >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxInterpolationOffset >= 0.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxInterpolationOffset >= 0.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxInterpolationOffset >= 0.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxMemoryAllocationCount >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxMemoryAllocationCount >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxMemoryAllocationCount >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorInputAttachments >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorInputAttachments >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorInputAttachments >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSampledImages >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSampledImages >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorSamplers >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorSamplers >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageBuffers >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageBuffers >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorStorageImages >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorStorageImages >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 12); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageDescriptorUniformBuffers >= 12), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageDescriptorUniformBuffers >= 12"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPerStageResources >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPerStageResources >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPushConstantsSize >= 128); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxPushConstantsSize >= 128), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxPushConstantsSize >= 128"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSampleMaskWords >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSampleMaskWords >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSampleMaskWords >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAllocationCount >= 4000); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAllocationCount >= 4000), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerAllocationCount >= 4000"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAnisotropy >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerAnisotropy >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerAnisotropy >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 2); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxSamplerLodBias >= 2), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxSamplerLodBias >= 2"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxStorageBufferRange >= 134217728); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxStorageBufferRange >= 134217728), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxStorageBufferRange >= 134217728"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerPatchOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerPatchOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerPatchOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexInputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexInputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerVertexInputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlPerVertexOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlPerVertexOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlTotalOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationControlTotalOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationControlTotalOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationInputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationInputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationEvaluationInputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationOutputComponents >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationEvaluationOutputComponents >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationEvaluationOutputComponents >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationGenerationLevel >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationGenerationLevel >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationGenerationLevel >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationPatchSize >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTessellationPatchSize >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTessellationPatchSize >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelBufferElements >= 65536); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelBufferElements >= 65536), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelBufferElements >= 65536"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelGatherOffset >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelGatherOffset >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelGatherOffset >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelOffset >= 7); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxTexelOffset >= 7), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxTexelOffset >= 7"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 16384); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxUniformBufferRange >= 16384), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxUniformBufferRange >= 16384"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributeOffset >= 2047); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributeOffset >= 2047), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputAttributeOffset >= 2047"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributes >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputAttributes >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputAttributes >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindingStride >= 2048); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindingStride >= 2048), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputBindingStride >= 2048"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindings >= 16); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexInputBindings >= 16), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexInputBindings >= 16"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxVertexOutputComponents >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxVertexOutputComponents >= 64"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[0] >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[0] >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewportDimensions[0] >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[1] >= 4096); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewportDimensions[1] >= 4096), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewportDimensions[1] >= 4096"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewports >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.maxViewports >= 1), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.maxViewports >= 1"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minInterpolationOffset <= 0.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minInterpolationOffset <= 0.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minInterpolationOffset <= 0.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment >= 64); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment >= 64), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minMemoryMapAlignment >= 64"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minMemoryMapAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minStorageBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelGatherOffset <= -8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelGatherOffset <= -8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelGatherOffset <= -8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelOffset <= -8); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minTexelOffset <= -8), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minTexelOffset <= -8"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.minUniformBufferOffsetAlignment <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.mipmapPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.mipmapPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize <= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize <= 256), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.nonCoherentAtomSize <= 256"); + ret = ret && ((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize & (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.nonCoherentAtomSize - 1)) == 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeGranularity <= 1.0"); + ret = ret && (isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)); + VP_DEBUG_COND_MSG(!(isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)), "Unsupported properties condition: isMultiple(1.0, prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeGranularity)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[0] <= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[0] <= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeRange[0] <= 1.0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[1] >= 1.0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.pointSizeRange[1] >= 1.0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.pointSizeRange[1] >= 1.0"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageDepthSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageIntegerSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sampledImageStencilSampleCounts contains (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sparseAddressSpaceSize >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.sparseAddressSpaceSize >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.sparseAddressSpaceSize >= 0"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.storageImageSampleCounts contains (VK_SAMPLE_COUNT_1_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelInterpolationOffsetBits >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelInterpolationOffsetBits >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subPixelInterpolationOffsetBits >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subPixelPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subPixelPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.subTexelPrecisionBits >= 4), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.subTexelPrecisionBits >= 4"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[0] <= -8192); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[0] <= -8192), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportBoundsRange[0] <= -8192"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[1] >= 8192); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportBoundsRange[1] >= 8192), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportBoundsRange[1] >= 8192"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportSubPixelBits >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.limits.viewportSubPixelBits >= 0), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.limits.viewportSubPixelBits >= 0"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyNonResidentStrict >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard2DBlockShape >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard2DMultisampleBlockShape >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceProperties2KHR->properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceProperties2KHR::properties.sparseProperties.residencyStandard3DBlockShape >= VK_FALSE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); + }, }; +} // namespace vulkan10requirements +namespace vulkan11requirements +{ static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.depthBiasClamp = VK_TRUE; - s->features.depthClamp = VK_TRUE; - s->features.drawIndirectFirstInstance = VK_TRUE; - s->features.fragmentStoresAndAtomics = VK_TRUE; - s->features.fullDrawIndexUint32 = VK_TRUE; - s->features.imageCubeArray = VK_TRUE; - s->features.independentBlend = VK_TRUE; - s->features.multiDrawIndirect = VK_TRUE; - s->features.occlusionQueryPrecise = VK_TRUE; - s->features.robustBufferAccess = VK_TRUE; - s->features.sampleRateShading = VK_TRUE; - s->features.samplerAnisotropy = VK_TRUE; - s->features.shaderImageGatherExtended = VK_TRUE; - s->features.shaderInt16 = VK_TRUE; - s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE; - s->features.shaderStorageBufferArrayDynamicIndexing = VK_TRUE; - s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE; - s->features.shaderStorageImageExtendedFormats = VK_TRUE; - s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceVulkan11Features* s = static_cast(static_cast(p)); - s->multiview = VK_TRUE; - s->samplerYcbcrConversion = VK_TRUE; - s->shaderDrawParameters = VK_TRUE; - s->storageBuffer16BitAccess = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - s->bufferDeviceAddress = VK_TRUE; - s->descriptorBindingPartiallyBound = VK_TRUE; - s->descriptorBindingSampledImageUpdateAfterBind = VK_TRUE; - s->descriptorBindingStorageBufferUpdateAfterBind = VK_TRUE; - s->descriptorBindingStorageImageUpdateAfterBind = VK_TRUE; - s->descriptorBindingStorageTexelBufferUpdateAfterBind = VK_TRUE; - s->descriptorBindingUniformTexelBufferUpdateAfterBind = VK_TRUE; - s->descriptorBindingUpdateUnusedWhilePending = VK_TRUE; - s->descriptorBindingVariableDescriptorCount = VK_TRUE; - s->descriptorIndexing = VK_TRUE; - s->hostQueryReset = VK_TRUE; - s->imagelessFramebuffer = VK_TRUE; - s->runtimeDescriptorArray = VK_TRUE; - s->samplerMirrorClampToEdge = VK_TRUE; - s->scalarBlockLayout = VK_TRUE; - s->separateDepthStencilLayouts = VK_TRUE; - s->shaderFloat16 = VK_TRUE; - s->shaderInt8 = VK_TRUE; - s->shaderSampledImageArrayNonUniformIndexing = VK_TRUE; - s->shaderStorageBufferArrayNonUniformIndexing = VK_TRUE; - s->shaderStorageImageArrayNonUniformIndexing = VK_TRUE; - s->shaderStorageTexelBufferArrayDynamicIndexing = VK_TRUE; - s->shaderStorageTexelBufferArrayNonUniformIndexing = VK_TRUE; - s->shaderSubgroupExtendedTypes = VK_TRUE; - s->shaderUniformBufferArrayNonUniformIndexing = VK_TRUE; - s->shaderUniformTexelBufferArrayDynamicIndexing = VK_TRUE; - s->shaderUniformTexelBufferArrayNonUniformIndexing = VK_TRUE; - s->storageBuffer8BitAccess = VK_TRUE; - s->subgroupBroadcastDynamicId = VK_TRUE; - s->timelineSemaphore = VK_TRUE; - s->uniformBufferStandardLayout = VK_TRUE; - s->vulkanMemoryModel = VK_TRUE; - s->vulkanMemoryModelDeviceScope = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: { - VkPhysicalDeviceVulkan13Features* s = static_cast(static_cast(p)); - s->computeFullSubgroups = VK_TRUE; - s->descriptorBindingInlineUniformBlockUpdateAfterBind = VK_TRUE; - s->dynamicRendering = VK_TRUE; - s->inlineUniformBlock = VK_TRUE; - s->maintenance4 = VK_TRUE; - s->pipelineCreationCacheControl = VK_TRUE; - s->robustImageAccess = VK_TRUE; - s->shaderDemoteToHelperInvocation = VK_TRUE; - s->shaderIntegerDotProduct = VK_TRUE; - s->shaderTerminateInvocation = VK_TRUE; - s->shaderZeroInitializeWorkgroupMemory = VK_TRUE; - s->subgroupSizeControl = VK_TRUE; - s->synchronization2 = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.depthBiasClamp == VK_TRUE); - ret = ret && (s->features.depthClamp == VK_TRUE); - ret = ret && (s->features.drawIndirectFirstInstance == VK_TRUE); - ret = ret && (s->features.fragmentStoresAndAtomics == VK_TRUE); - ret = ret && (s->features.fullDrawIndexUint32 == VK_TRUE); - ret = ret && (s->features.imageCubeArray == VK_TRUE); - ret = ret && (s->features.independentBlend == VK_TRUE); - ret = ret && (s->features.multiDrawIndirect == VK_TRUE); - ret = ret && (s->features.occlusionQueryPrecise == VK_TRUE); - ret = ret && (s->features.robustBufferAccess == VK_TRUE); - ret = ret && (s->features.sampleRateShading == VK_TRUE); - ret = ret && (s->features.samplerAnisotropy == VK_TRUE); - ret = ret && (s->features.shaderImageGatherExtended == VK_TRUE); - ret = ret && (s->features.shaderInt16 == VK_TRUE); - ret = ret && (s->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->features.shaderStorageImageExtendedFormats == VK_TRUE); - ret = ret && (s->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceVulkan11Features* s = static_cast(static_cast(p)); - ret = ret && (s->multiview == VK_TRUE); - ret = ret && (s->samplerYcbcrConversion == VK_TRUE); - ret = ret && (s->shaderDrawParameters == VK_TRUE); - ret = ret && (s->storageBuffer16BitAccess == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - ret = ret && (s->bufferDeviceAddress == VK_TRUE); - ret = ret && (s->descriptorBindingPartiallyBound == VK_TRUE); - ret = ret && (s->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE); - ret = ret && (s->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE); - ret = ret && (s->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE); - ret = ret && (s->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE); - ret = ret && (s->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE); - ret = ret && (s->descriptorBindingUpdateUnusedWhilePending == VK_TRUE); - ret = ret && (s->descriptorBindingVariableDescriptorCount == VK_TRUE); - ret = ret && (s->descriptorIndexing == VK_TRUE); - ret = ret && (s->hostQueryReset == VK_TRUE); - ret = ret && (s->imagelessFramebuffer == VK_TRUE); - ret = ret && (s->runtimeDescriptorArray == VK_TRUE); - ret = ret && (s->samplerMirrorClampToEdge == VK_TRUE); - ret = ret && (s->scalarBlockLayout == VK_TRUE); - ret = ret && (s->separateDepthStencilLayouts == VK_TRUE); - ret = ret && (s->shaderFloat16 == VK_TRUE); - ret = ret && (s->shaderInt8 == VK_TRUE); - ret = ret && (s->shaderSampledImageArrayNonUniformIndexing == VK_TRUE); - ret = ret && (s->shaderStorageBufferArrayNonUniformIndexing == VK_TRUE); - ret = ret && (s->shaderStorageImageArrayNonUniformIndexing == VK_TRUE); - ret = ret && (s->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE); - ret = ret && (s->shaderSubgroupExtendedTypes == VK_TRUE); - ret = ret && (s->shaderUniformBufferArrayNonUniformIndexing == VK_TRUE); - ret = ret && (s->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE); - ret = ret && (s->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE); - ret = ret && (s->storageBuffer8BitAccess == VK_TRUE); - ret = ret && (s->subgroupBroadcastDynamicId == VK_TRUE); - ret = ret && (s->timelineSemaphore == VK_TRUE); - ret = ret && (s->uniformBufferStandardLayout == VK_TRUE); - ret = ret && (s->vulkanMemoryModel == VK_TRUE); - ret = ret && (s->vulkanMemoryModelDeviceScope == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: { - VkPhysicalDeviceVulkan13Features* s = static_cast(static_cast(p)); - ret = ret && (s->computeFullSubgroups == VK_TRUE); - ret = ret && (s->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE); - ret = ret && (s->dynamicRendering == VK_TRUE); - ret = ret && (s->inlineUniformBlock == VK_TRUE); - ret = ret && (s->maintenance4 == VK_TRUE); - ret = ret && (s->pipelineCreationCacheControl == VK_TRUE); - ret = ret && (s->robustImageAccess == VK_TRUE); - ret = ret && (s->shaderDemoteToHelperInvocation == VK_TRUE); - ret = ret && (s->shaderIntegerDotProduct == VK_TRUE); - ret = ret && (s->shaderTerminateInvocation == VK_TRUE); - ret = ret && (s->shaderZeroInitializeWorkgroupMemory == VK_TRUE); - ret = ret && (s->subgroupSizeControl == VK_TRUE); - ret = ret && (s->synchronization2 == VK_TRUE); - } break; - default: break; - } - return ret; - } + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *s = static_cast(static_cast(p)); + s->multiview = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + VkPhysicalDeviceVulkan11Features *prettify_VkPhysicalDeviceVulkan11Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Features->multiview == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan11Features::multiview == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + { + VkPhysicalDeviceVulkan11Properties *s = static_cast(static_cast(p)); + s->maxMemoryAllocationSize = 1073741824; + s->maxMultiviewInstanceIndex = 134217727; + s->maxMultiviewViewCount = 6; + s->maxPerSetDescriptors = 1024; + s->subgroupSize = 1; + s->subgroupSupportedOperations |= (VK_SUBGROUP_FEATURE_BASIC_BIT); + s->subgroupSupportedStages |= (VK_SHADER_STAGE_COMPUTE_BIT); + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + { + VkPhysicalDeviceVulkan11Properties *prettify_VkPhysicalDeviceVulkan11Properties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->maxMemoryAllocationSize >= 1073741824); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->maxMemoryAllocationSize >= 1073741824), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::maxMemoryAllocationSize >= 1073741824"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewInstanceIndex >= 134217727); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewInstanceIndex >= 134217727), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::maxMultiviewInstanceIndex >= 134217727"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewViewCount >= 6); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->maxMultiviewViewCount >= 6), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::maxMultiviewViewCount >= 6"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->maxPerSetDescriptors >= 1024); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->maxPerSetDescriptors >= 1024), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::maxPerSetDescriptors >= 1024"); + ret = ret && (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize >= 1); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize >= 1), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::subgroupSize >= 1"); + ret = ret && ((prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize & (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize - 1)) == 0); + VP_DEBUG_COND_MSG(!((prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize & (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize - 1)) == 0), "Unsupported properties condition: (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize & (prettify_VkPhysicalDeviceVulkan11Properties->subgroupSize - 1)) == 0"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::subgroupSupportedOperations contains (VK_SUBGROUP_FEATURE_BASIC_BIT)"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedStages, (VK_SHADER_STAGE_COMPUTE_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan11Properties->subgroupSupportedStages, (VK_SHADER_STAGE_COMPUTE_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan11Properties::subgroupSupportedStages contains (VK_SHADER_STAGE_COMPUTE_BIT)"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); + }, }; +} // namespace vulkan11requirements +namespace vulkan12requirements +{ + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *s = static_cast(static_cast(p)); + s->hostQueryReset = VK_TRUE; + s->imagelessFramebuffer = VK_TRUE; + s->separateDepthStencilLayouts = VK_TRUE; + s->shaderSubgroupExtendedTypes = VK_TRUE; + s->subgroupBroadcastDynamicId = VK_TRUE; + s->timelineSemaphore = VK_TRUE; + s->uniformBufferStandardLayout = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *prettify_VkPhysicalDeviceVulkan12Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->hostQueryReset == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::hostQueryReset == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->imagelessFramebuffer == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::imagelessFramebuffer == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->separateDepthStencilLayouts == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::separateDepthStencilLayouts == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->shaderSubgroupExtendedTypes == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->shaderSubgroupExtendedTypes == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::shaderSubgroupExtendedTypes == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->subgroupBroadcastDynamicId == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->subgroupBroadcastDynamicId == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::subgroupBroadcastDynamicId == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->timelineSemaphore == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::timelineSemaphore == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->uniformBufferStandardLayout == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::uniformBufferStandardLayout == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + { + VkPhysicalDeviceVulkan12Properties *s = static_cast(static_cast(p)); + s->filterMinmaxImageComponentMapping = VK_FALSE; + s->filterMinmaxSingleComponentFormats = VK_FALSE; + s->framebufferIntegerColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); + s->independentResolve = VK_FALSE; + s->independentResolveNone = VK_FALSE; + s->maxDescriptorSetUpdateAfterBindInputAttachments = 0; + s->maxDescriptorSetUpdateAfterBindSampledImages = 0; + s->maxDescriptorSetUpdateAfterBindSamplers = 0; + s->maxDescriptorSetUpdateAfterBindStorageBuffers = 0; + s->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = 0; + s->maxDescriptorSetUpdateAfterBindStorageImages = 0; + s->maxDescriptorSetUpdateAfterBindUniformBuffers = 0; + s->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = 0; + s->maxPerStageDescriptorUpdateAfterBindInputAttachments = 0; + s->maxPerStageDescriptorUpdateAfterBindSampledImages = 0; + s->maxPerStageDescriptorUpdateAfterBindSamplers = 0; + s->maxPerStageDescriptorUpdateAfterBindStorageBuffers = 0; + s->maxPerStageDescriptorUpdateAfterBindStorageImages = 0; + s->maxPerStageDescriptorUpdateAfterBindUniformBuffers = 0; + s->maxPerStageUpdateAfterBindResources = 0; + s->maxTimelineSemaphoreValueDifference = 2147483647; + s->maxUpdateAfterBindDescriptorsInAllPools = 0; + s->quadDivergentImplicitLod = VK_FALSE; + s->robustBufferAccessUpdateAfterBind = VK_FALSE; + s->shaderDenormFlushToZeroFloat16 = VK_FALSE; + s->shaderDenormFlushToZeroFloat32 = VK_FALSE; + s->shaderDenormFlushToZeroFloat64 = VK_FALSE; + s->shaderDenormPreserveFloat16 = VK_FALSE; + s->shaderDenormPreserveFloat32 = VK_FALSE; + s->shaderDenormPreserveFloat64 = VK_FALSE; + s->shaderInputAttachmentArrayNonUniformIndexingNative = VK_FALSE; + s->shaderRoundingModeRTEFloat16 = VK_FALSE; + s->shaderRoundingModeRTEFloat32 = VK_FALSE; + s->shaderRoundingModeRTEFloat64 = VK_FALSE; + s->shaderRoundingModeRTZFloat16 = VK_FALSE; + s->shaderRoundingModeRTZFloat32 = VK_FALSE; + s->shaderRoundingModeRTZFloat64 = VK_FALSE; + s->shaderSampledImageArrayNonUniformIndexingNative = VK_FALSE; + s->shaderSignedZeroInfNanPreserveFloat16 = VK_FALSE; + s->shaderSignedZeroInfNanPreserveFloat32 = VK_FALSE; + s->shaderSignedZeroInfNanPreserveFloat64 = VK_FALSE; + s->shaderStorageBufferArrayNonUniformIndexingNative = VK_FALSE; + s->shaderStorageImageArrayNonUniformIndexingNative = VK_FALSE; + s->shaderUniformBufferArrayNonUniformIndexingNative = VK_FALSE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + { + VkPhysicalDeviceVulkan12Properties *prettify_VkPhysicalDeviceVulkan12Properties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->filterMinmaxImageComponentMapping >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->filterMinmaxImageComponentMapping >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::filterMinmaxImageComponentMapping >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->filterMinmaxSingleComponentFormats >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->filterMinmaxSingleComponentFormats >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::filterMinmaxSingleComponentFormats >= VK_FALSE"); + ret = ret && (vpCheckFlags(prettify_VkPhysicalDeviceVulkan12Properties->framebufferIntegerColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); + VP_DEBUG_COND_MSG(!(vpCheckFlags(prettify_VkPhysicalDeviceVulkan12Properties->framebufferIntegerColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT))), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::framebufferIntegerColorSampleCounts contains (VK_SAMPLE_COUNT_1_BIT)"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->independentResolve >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->independentResolve >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::independentResolve >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->independentResolveNone >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->independentResolveNone >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::independentResolveNone >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindInputAttachments >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindInputAttachments >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindInputAttachments >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSampledImages >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSampledImages >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindSampledImages >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSamplers >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindSamplers >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindSamplers >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffers >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffers >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindStorageBuffers >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageImages >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindStorageImages >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindStorageImages >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffers >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffers >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindUniformBuffers >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindInputAttachments >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindInputAttachments >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindInputAttachments >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSampledImages >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSampledImages >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindSampledImages >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSamplers >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindSamplers >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindSamplers >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageImages >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindStorageImages >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindStorageImages >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageUpdateAfterBindResources >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxPerStageUpdateAfterBindResources >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxPerStageUpdateAfterBindResources >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxTimelineSemaphoreValueDifference >= 2147483647); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxTimelineSemaphoreValueDifference >= 2147483647), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxTimelineSemaphoreValueDifference >= 2147483647"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->maxUpdateAfterBindDescriptorsInAllPools >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->maxUpdateAfterBindDescriptorsInAllPools >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::maxUpdateAfterBindDescriptorsInAllPools >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->quadDivergentImplicitLod >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->quadDivergentImplicitLod >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::quadDivergentImplicitLod >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->robustBufferAccessUpdateAfterBind >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->robustBufferAccessUpdateAfterBind >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::robustBufferAccessUpdateAfterBind >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormFlushToZeroFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormFlushToZeroFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormFlushToZeroFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormFlushToZeroFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormPreserveFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormPreserveFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderDenormPreserveFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderDenormPreserveFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderInputAttachmentArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderInputAttachmentArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderInputAttachmentArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTEFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTEFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTEFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTEFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTZFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTZFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderRoundingModeRTZFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderRoundingModeRTZFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderSampledImageArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderSampledImageArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderSampledImageArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat16 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat16 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderSignedZeroInfNanPreserveFloat16 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat32 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat32 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderSignedZeroInfNanPreserveFloat32 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat64 >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderSignedZeroInfNanPreserveFloat64 >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderSignedZeroInfNanPreserveFloat64 >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderStorageBufferArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderStorageBufferArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderStorageBufferArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderStorageImageArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderStorageImageArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderStorageImageArrayNonUniformIndexingNative >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Properties->shaderUniformBufferArrayNonUniformIndexingNative >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Properties->shaderUniformBufferArrayNonUniformIndexingNative >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan12Properties::shaderUniformBufferArrayNonUniformIndexingNative >= VK_FALSE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpStructChainerDesc chainerDesc = { + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } }; +} // namespace vulkan12requirements +namespace vulkan13requirements +{ + +static const VpFeatureDesc featureDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *s = static_cast(static_cast(p)); + s->bufferDeviceAddress = VK_TRUE; + s->vulkanMemoryModel = VK_TRUE; + s->vulkanMemoryModelDeviceScope = VK_TRUE; + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + { + VkPhysicalDeviceVulkan13Features *s = static_cast(static_cast(p)); + s->computeFullSubgroups = VK_TRUE; + s->dynamicRendering = VK_TRUE; + s->inlineUniformBlock = VK_TRUE; + s->maintenance4 = VK_TRUE; + s->pipelineCreationCacheControl = VK_TRUE; + s->robustImageAccess = VK_TRUE; + s->shaderDemoteToHelperInvocation = VK_TRUE; + s->shaderIntegerDotProduct = VK_TRUE; + s->shaderTerminateInvocation = VK_TRUE; + s->shaderZeroInitializeWorkgroupMemory = VK_TRUE; + s->subgroupSizeControl = VK_TRUE; + s->synchronization2 = VK_TRUE; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + VkPhysicalDeviceVulkan12Features *prettify_VkPhysicalDeviceVulkan12Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->bufferDeviceAddress == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->bufferDeviceAddress == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::bufferDeviceAddress == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModel == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModel == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::vulkanMemoryModel == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModelDeviceScope == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan12Features->vulkanMemoryModelDeviceScope == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan12Features::vulkanMemoryModelDeviceScope == VK_TRUE"); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + { + VkPhysicalDeviceVulkan13Features *prettify_VkPhysicalDeviceVulkan13Features = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->computeFullSubgroups == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->computeFullSubgroups == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::computeFullSubgroups == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->dynamicRendering == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->dynamicRendering == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::dynamicRendering == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->inlineUniformBlock == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->inlineUniformBlock == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::inlineUniformBlock == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->maintenance4 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->maintenance4 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::maintenance4 == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->pipelineCreationCacheControl == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->pipelineCreationCacheControl == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::pipelineCreationCacheControl == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->robustImageAccess == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->robustImageAccess == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::robustImageAccess == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderDemoteToHelperInvocation == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderDemoteToHelperInvocation == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderDemoteToHelperInvocation == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderIntegerDotProduct == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderIntegerDotProduct == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderIntegerDotProduct == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderTerminateInvocation == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderTerminateInvocation == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderTerminateInvocation == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->shaderZeroInitializeWorkgroupMemory == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->shaderZeroInitializeWorkgroupMemory == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::shaderZeroInitializeWorkgroupMemory == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->subgroupSizeControl == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->subgroupSizeControl == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::subgroupSizeControl == VK_TRUE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Features->synchronization2 == VK_TRUE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Features->synchronization2 == VK_TRUE), "Unsupported feature condition: VkPhysicalDeviceVulkan13Features::synchronization2 == VK_TRUE"); + } + break; + default: + break; + } + return ret; + }}; + +static const VpPropertyDesc propertyDesc = { + [](VkBaseOutStructure *p) { + (void) p; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: + { + VkPhysicalDeviceVulkan13Properties *s = static_cast(static_cast(p)); + s->integerDotProduct16BitMixedSignednessAccelerated = VK_FALSE; + s->integerDotProduct16BitSignedAccelerated = VK_FALSE; + s->integerDotProduct16BitUnsignedAccelerated = VK_FALSE; + s->integerDotProduct32BitMixedSignednessAccelerated = VK_FALSE; + s->integerDotProduct32BitSignedAccelerated = VK_FALSE; + s->integerDotProduct32BitUnsignedAccelerated = VK_FALSE; + s->integerDotProduct4x8BitPackedMixedSignednessAccelerated = VK_FALSE; + s->integerDotProduct4x8BitPackedSignedAccelerated = VK_FALSE; + s->integerDotProduct4x8BitPackedUnsignedAccelerated = VK_FALSE; + s->integerDotProduct64BitMixedSignednessAccelerated = VK_FALSE; + s->integerDotProduct64BitSignedAccelerated = VK_FALSE; + s->integerDotProduct64BitUnsignedAccelerated = VK_FALSE; + s->integerDotProduct8BitMixedSignednessAccelerated = VK_FALSE; + s->integerDotProduct8BitSignedAccelerated = VK_FALSE; + s->integerDotProduct8BitUnsignedAccelerated = VK_FALSE; + s->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = VK_FALSE; + s->integerDotProductAccumulatingSaturating16BitSignedAccelerated = VK_FALSE; + s->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = VK_FALSE; + s->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = VK_FALSE; + s->integerDotProductAccumulatingSaturating32BitSignedAccelerated = VK_FALSE; + s->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = VK_FALSE; + s->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = VK_FALSE; + s->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = VK_FALSE; + s->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = VK_FALSE; + s->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = VK_FALSE; + s->integerDotProductAccumulatingSaturating64BitSignedAccelerated = VK_FALSE; + s->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = VK_FALSE; + s->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = VK_FALSE; + s->integerDotProductAccumulatingSaturating8BitSignedAccelerated = VK_FALSE; + s->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = VK_FALSE; + s->maxBufferSize = 1073741824; + s->maxComputeWorkgroupSubgroups = 0; + s->maxDescriptorSetInlineUniformBlocks = 4; + s->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = 4; + s->maxInlineUniformBlockSize = 256; + s->maxInlineUniformTotalSize = 256; + s->maxPerStageDescriptorInlineUniformBlocks = 4; + s->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = 4; + } + break; + default: + break; + } + }, + [](VkBaseOutStructure *p) -> bool { + (void) p; + bool ret = true; + switch (p->sType) + { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: + { + VkPhysicalDeviceVulkan13Properties *prettify_VkPhysicalDeviceVulkan13Properties = static_cast(static_cast(p)); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct16BitMixedSignednessAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct16BitMixedSignednessAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProduct16BitMixedSignednessAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct16BitSignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct16BitSignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProduct16BitSignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct16BitUnsignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct16BitUnsignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProduct16BitUnsignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct32BitMixedSignednessAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct32BitMixedSignednessAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProduct32BitMixedSignednessAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct32BitSignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct32BitSignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProduct32BitSignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct32BitUnsignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct32BitUnsignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProduct32BitUnsignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct4x8BitPackedMixedSignednessAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct4x8BitPackedMixedSignednessAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProduct4x8BitPackedMixedSignednessAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct4x8BitPackedSignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct4x8BitPackedSignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProduct4x8BitPackedSignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct4x8BitPackedUnsignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct4x8BitPackedUnsignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProduct4x8BitPackedUnsignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct64BitMixedSignednessAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct64BitMixedSignednessAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProduct64BitMixedSignednessAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct64BitSignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct64BitSignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProduct64BitSignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct64BitUnsignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct64BitUnsignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProduct64BitUnsignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct8BitMixedSignednessAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct8BitMixedSignednessAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProduct8BitMixedSignednessAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct8BitSignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct8BitSignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProduct8BitSignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct8BitUnsignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProduct8BitUnsignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProduct8BitUnsignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating16BitSignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating16BitSignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProductAccumulatingSaturating16BitSignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProductAccumulatingSaturating16BitUnsignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating32BitSignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating32BitSignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProductAccumulatingSaturating32BitSignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProductAccumulatingSaturating32BitUnsignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating64BitSignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating64BitSignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProductAccumulatingSaturating64BitSignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProductAccumulatingSaturating64BitUnsignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating8BitSignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating8BitSignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProductAccumulatingSaturating8BitSignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated >= VK_FALSE); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated >= VK_FALSE), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::integerDotProductAccumulatingSaturating8BitUnsignedAccelerated >= VK_FALSE"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->maxBufferSize >= 1073741824); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->maxBufferSize >= 1073741824), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::maxBufferSize >= 1073741824"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->maxComputeWorkgroupSubgroups >= 0); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->maxComputeWorkgroupSubgroups >= 0), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::maxComputeWorkgroupSubgroups >= 0"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->maxDescriptorSetInlineUniformBlocks >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->maxDescriptorSetInlineUniformBlocks >= 4), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::maxDescriptorSetInlineUniformBlocks >= 4"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->maxDescriptorSetUpdateAfterBindInlineUniformBlocks >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->maxDescriptorSetUpdateAfterBindInlineUniformBlocks >= 4), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::maxDescriptorSetUpdateAfterBindInlineUniformBlocks >= 4"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->maxInlineUniformBlockSize >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->maxInlineUniformBlockSize >= 256), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::maxInlineUniformBlockSize >= 256"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->maxInlineUniformTotalSize >= 256); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->maxInlineUniformTotalSize >= 256), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::maxInlineUniformTotalSize >= 256"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->maxPerStageDescriptorInlineUniformBlocks >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->maxPerStageDescriptorInlineUniformBlocks >= 4), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::maxPerStageDescriptorInlineUniformBlocks >= 4"); + ret = ret && (prettify_VkPhysicalDeviceVulkan13Properties->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks >= 4); + VP_DEBUG_COND_MSG(!(prettify_VkPhysicalDeviceVulkan13Properties->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks >= 4), "Unsupported properties condition: VkPhysicalDeviceVulkan13Properties::maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks >= 4"); + } + break; + default: + break; + } + return ret; + }}; static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); + pfnCb(p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr}; + VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties}; + VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties}; + p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); + pfnCb(p, pUser); + }, + [](uint32_t count, VkBaseOutStructure *p, void *pUser, PFN_vpStructArrayChainerCb pfnCb) { + pfnCb(count, p, pUser); + }, + [](VkBaseOutStructure *p, void *pUser, PFN_vpStructChainerCb pfnCb) { + pfnCb(p, pUser); + }, +}; +} // namespace vulkan13requirements +} // namespace blocks +} // namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_3 +#endif // VP_LUNARG_minimum_requirements_1_3 + +#ifdef VP_ANDROID_15_minimums +namespace VP_ANDROID_15_MINIMUMS +{ +namespace blocks +{ +namespace MUST +{ +static const VpVariantDesc variants[] = { + { + "MUST", + static_cast(std::size(blocks::MUST::instanceExtensions)), + blocks::MUST::instanceExtensions, + static_cast(std::size(blocks::MUST::deviceExtensions)), + blocks::MUST::deviceExtensions, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::MUST::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::MUST::propertyDesc, + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(formatStructTypes)), + formatStructTypes, + static_cast(std::size(blocks::MUST::formatDesc)), + blocks::MUST::formatDesc, + blocks::MUST::chainerDesc, + 0, + nullptr, + }, +}; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace MUST + +namespace primitivesGeneratedQuery_pipelineStatisticsQuery_ +{ +static const VpVariantDesc variants[] = { + { + "primitivesGeneratedQuery", + 0, + nullptr, + static_cast(std::size(blocks::primitivesGeneratedQuery::deviceExtensions)), + blocks::primitivesGeneratedQuery::deviceExtensions, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::primitivesGeneratedQuery::featureDesc, + 0, + nullptr, + blocks::primitivesGeneratedQuery::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::primitivesGeneratedQuery::chainerDesc, + 0, + nullptr, + }, + { + "pipelineStatisticsQuery", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::pipelineStatisticsQuery::featureDesc, + 0, + nullptr, + blocks::pipelineStatisticsQuery::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::pipelineStatisticsQuery::chainerDesc, + 0, + nullptr, }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); +}; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace primitivesGeneratedQuery_pipelineStatisticsQuery_ + +namespace swBresenhamLines_hwBresenhamLines_ +{ +static const VpVariantDesc variants[] = { + { + "swBresenhamLines", + 0, + nullptr, + static_cast(std::size(blocks::swBresenhamLines::deviceExtensions)), + blocks::swBresenhamLines::deviceExtensions, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::swBresenhamLines::featureDesc, + 0, + nullptr, + blocks::swBresenhamLines::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::swBresenhamLines::chainerDesc, + 0, + nullptr, }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); + { + "hwBresenhamLines", + 0, + nullptr, + static_cast(std::size(blocks::hwBresenhamLines::deviceExtensions)), + blocks::hwBresenhamLines::deviceExtensions, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::hwBresenhamLines::featureDesc, + 0, + nullptr, + blocks::hwBresenhamLines::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::hwBresenhamLines::chainerDesc, + 0, + nullptr, }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); +}; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace swBresenhamLines_hwBresenhamLines_ +} // namespace blocks + +static const VpCapabilitiesDesc capabilities[] = { + {blocks::MUST::variantCount, blocks::MUST::variants}, + {blocks::primitivesGeneratedQuery_pipelineStatisticsQuery_::variantCount, blocks::primitivesGeneratedQuery_pipelineStatisticsQuery_::variants}, + {blocks::swBresenhamLines_hwBresenhamLines_::variantCount, blocks::swBresenhamLines_hwBresenhamLines_::variants}, +}; +static const uint32_t capabilityCount = static_cast(std::size(capabilities)); + +static const VpProfileProperties profiles[] = { + {VP_ANDROID_BASELINE_2022_NAME, VP_ANDROID_BASELINE_2022_SPEC_VERSION}, +}; +static const uint32_t profileCount = static_cast(std::size(profiles)); +} // namespace VP_ANDROID_15_MINIMUMS +#endif // VP_ANDROID_15_minimums + +#ifdef VP_ANDROID_16_minimums +namespace VP_ANDROID_16_MINIMUMS +{ +namespace blocks +{ +namespace MUST +{ +static const VpVariantDesc variants[] = { + { + "MUST", + 0, + nullptr, + static_cast(std::size(blocks::MUST::deviceExtensions)), + blocks::MUST::deviceExtensions, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::MUST::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::MUST::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::MUST::chainerDesc, + 0, + nullptr, }, }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace MUST -namespace vulkan10requirements_roadmap2024 { -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.multiDrawIndirect = VK_TRUE; - s->features.shaderImageGatherExtended = VK_TRUE; - s->features.shaderInt16 = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.multiDrawIndirect == VK_TRUE); - ret = ret && (s->features.shaderImageGatherExtended == VK_TRUE); - ret = ret && (s->features.shaderInt16 == VK_TRUE); - } break; - default: break; - } - return ret; - } +namespace multisampledToSingleSampled_shaderStencilExport_ +{ +static const VpVariantDesc variants[] = { + { + "multisampledToSingleSampled", + 0, + nullptr, + static_cast(std::size(blocks::multisampledToSingleSampled::deviceExtensions)), + blocks::multisampledToSingleSampled::deviceExtensions, + 0, + nullptr, + blocks::multisampledToSingleSampled::featureDesc, + 0, + nullptr, + blocks::multisampledToSingleSampled::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::multisampledToSingleSampled::chainerDesc, + 0, + nullptr, + }, + { + "shaderStencilExport", + 0, + nullptr, + static_cast(std::size(blocks::shaderStencilExport::deviceExtensions)), + blocks::shaderStencilExport::deviceExtensions, + 0, + nullptr, + blocks::shaderStencilExport::featureDesc, + 0, + nullptr, + blocks::shaderStencilExport::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::shaderStencilExport::chainerDesc, + 0, + nullptr, + }, }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace multisampledToSingleSampled_shaderStencilExport_ +} // namespace blocks -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - s->properties.limits.maxBoundDescriptorSets = 7; - s->properties.limits.maxColorAttachments = 8; - s->properties.limits.timestampComputeAndGraphics = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->properties.limits.maxBoundDescriptorSets >= 7); - ret = ret && (s->properties.limits.maxColorAttachments >= 8); - ret = ret && (vpCheckFlags(s->properties.limits.timestampComputeAndGraphics, VK_TRUE)); - } break; - default: break; - } - return ret; - } +static const VpCapabilitiesDesc capabilities[] = { + {blocks::MUST::variantCount, blocks::MUST::variants}, + {blocks::multisampledToSingleSampled_shaderStencilExport_::variantCount, blocks::multisampledToSingleSampled_shaderStencilExport_::variants}, }; +static const uint32_t capabilityCount = static_cast(std::size(capabilities)); -static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, -}; -} //namespace vulkan10requirements_roadmap2024 -namespace vulkan11requirements_roadmap2024 { -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceVulkan11Features* s = static_cast(static_cast(p)); - s->shaderDrawParameters = VK_TRUE; - s->storageBuffer16BitAccess = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceVulkan11Features* s = static_cast(static_cast(p)); - ret = ret && (s->shaderDrawParameters == VK_TRUE); - ret = ret && (s->storageBuffer16BitAccess == VK_TRUE); - } break; - default: break; - } - return ret; - } +static const VpProfileProperties profiles[] = { + {VP_ANDROID_BASELINE_2022_NAME, VP_ANDROID_BASELINE_2022_SPEC_VERSION}, + {VP_ANDROID_15_MINIMUMS_NAME, VP_ANDROID_15_MINIMUMS_SPEC_VERSION}, }; +static const uint32_t profileCount = static_cast(std::size(profiles)); +} // namespace VP_ANDROID_16_MINIMUMS +#endif // VP_ANDROID_16_minimums -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; +#ifdef VP_ANDROID_baseline_2021 +namespace VP_ANDROID_BASELINE_2021 +{ +static const VpVariantDesc mergedCapabilities[] = { + { + "MERGED", + static_cast(std::size(instanceExtensions)), + instanceExtensions, + static_cast(std::size(deviceExtensions)), + deviceExtensions, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + featureDesc, + 0, + nullptr, + propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + chainerDesc, + 0, + nullptr, }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } }; -static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); +namespace blocks +{ +namespace baseline +{ +static const VpVariantDesc variants[] = { + { + "baseline", + static_cast(std::size(blocks::baseline::instanceExtensions)), + blocks::baseline::instanceExtensions, + static_cast(std::size(blocks::baseline::deviceExtensions)), + blocks::baseline::deviceExtensions, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::baseline::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::baseline::propertyDesc, + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(formatStructTypes)), + formatStructTypes, + static_cast(std::size(blocks::baseline::formatDesc)), + blocks::baseline::formatDesc, + blocks::baseline::chainerDesc, + 0, + nullptr, }, }; -} //namespace vulkan11requirements_roadmap2024 -namespace vulkan12requirements_roadmap2024 { -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - s->shaderFloat16 = VK_TRUE; - s->shaderInt8 = VK_TRUE; - s->storageBuffer8BitAccess = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - ret = ret && (s->shaderFloat16 == VK_TRUE); - ret = ret && (s->shaderInt8 == VK_TRUE); - ret = ret && (s->storageBuffer8BitAccess == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace baseline +} // namespace blocks -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: { - VkPhysicalDeviceVulkan12Properties* s = static_cast(static_cast(p)); - s->shaderRoundingModeRTEFloat16 = VK_TRUE; - s->shaderRoundingModeRTEFloat32 = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: { - VkPhysicalDeviceVulkan12Properties* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->shaderRoundingModeRTEFloat16, VK_TRUE)); - ret = ret && (vpCheckFlags(s->shaderRoundingModeRTEFloat32, VK_TRUE)); - } break; - default: break; - } - return ret; - } +static const VpCapabilitiesDesc capabilities[] = { + {blocks::baseline::variantCount, blocks::baseline::variants}, }; +static const uint32_t capabilityCount = static_cast(std::size(capabilities)); +} // namespace VP_ANDROID_BASELINE_2021 +#endif // VP_ANDROID_baseline_2021 -static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, -}; -} //namespace vulkan12requirements_roadmap2024 -namespace vulkan13requirements_roadmap2024 { -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; +#ifdef VP_ANDROID_baseline_2022 +namespace VP_ANDROID_BASELINE_2022 +{ +static const VpVariantDesc mergedCapabilities[] = { + { + "MERGED", + static_cast(std::size(instanceExtensions)), + instanceExtensions, + static_cast(std::size(deviceExtensions)), + deviceExtensions, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + featureDesc, + 0, + nullptr, + propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + chainerDesc, + 0, + nullptr, }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } }; -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; +namespace blocks +{ +namespace baseline +{ +static const VpVariantDesc variants[] = { + { + "baseline", + static_cast(std::size(blocks::baseline::instanceExtensions)), + blocks::baseline::instanceExtensions, + static_cast(std::size(blocks::baseline::deviceExtensions)), + blocks::baseline::deviceExtensions, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::baseline::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::baseline::propertyDesc, + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(formatStructTypes)), + formatStructTypes, + static_cast(std::size(blocks::baseline::formatDesc)), + blocks::baseline::formatDesc, + blocks::baseline::chainerDesc, + 0, + nullptr, }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace baseline +} // namespace blocks -static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, -}; -} //namespace vulkan13requirements_roadmap2024 -namespace vulkanextensionrequirements_roadmap2024 { -static const VkExtensionProperties deviceExtensions[] = { - VkExtensionProperties{ VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_MAINTENANCE_5_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_MAP_MEMORY_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME, 1 }, - VkExtensionProperties{ VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, 1 }, +static const VpCapabilitiesDesc capabilities[] = { + {blocks::baseline::variantCount, blocks::baseline::variants}, }; +static const uint32_t capabilityCount = static_cast(std::size(capabilities)); +} // namespace VP_ANDROID_BASELINE_2022 +#endif // VP_ANDROID_baseline_2022 -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; +#ifdef VP_KHR_roadmap_2022 +namespace VP_KHR_ROADMAP_2022 +{ +static const VpVariantDesc mergedCapabilities[] = { + { + "MERGED", + 0, + nullptr, + static_cast(std::size(deviceExtensions)), + deviceExtensions, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + featureDesc, + 0, + nullptr, + propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + chainerDesc, + 0, + nullptr, }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } }; -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; +namespace blocks +{ +namespace vulkan10requirements +{ +static const VpVariantDesc variants[] = { + { + "vulkan10requirements", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan10requirements::featureDesc, + 0, + nullptr, + blocks::vulkan10requirements::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan10requirements::chainerDesc, + 0, + nullptr, }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan10requirements -static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); +namespace vulkan10requirements_roadmap2022 +{ +static const VpVariantDesc variants[] = { + { + "vulkan10requirements_roadmap2022", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan10requirements_roadmap2022::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::vulkan10requirements_roadmap2022::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan10requirements_roadmap2022::chainerDesc, + 0, + nullptr, }, }; -} //namespace vulkanextensionrequirements_roadmap2024 -} // namespace VP_KHR_ROADMAP_2024 -#endif // VP_KHR_roadmap_2024 - -#ifdef VP_LUNARG_minimum_requirements_1_0 -namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_0 { - -static const VkStructureType featureStructTypes[] = { - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, -}; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan10requirements_roadmap2022 -static const VkStructureType propertyStructTypes[] = { - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, -}; - -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.robustBufferAccess = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.robustBufferAccess == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; - -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; +namespace vulkan11requirements +{ +static const VpVariantDesc variants[] = { + { + "vulkan11requirements", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan11requirements::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::vulkan11requirements::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan11requirements::chainerDesc, + 0, + nullptr, }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan11requirements -static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - p->pNext = static_cast(static_cast(nullptr)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - p->pNext = static_cast(static_cast(nullptr)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); +namespace vulkan11requirements_roadmap2022 +{ +static const VpVariantDesc variants[] = { + { + "vulkan11requirements_roadmap2022", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan11requirements_roadmap2022::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::vulkan11requirements_roadmap2022::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan11requirements_roadmap2022::chainerDesc, + 0, + nullptr, }, }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan11requirements_roadmap2022 -namespace vulkan10requirements { -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.robustBufferAccess = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.robustBufferAccess == VK_TRUE); - } break; - default: break; - } - return ret; - } +namespace vulkan12requirements +{ +static const VpVariantDesc variants[] = { + { + "vulkan12requirements", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan12requirements::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::vulkan12requirements::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan12requirements::chainerDesc, + 0, + nullptr, + }, }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan12requirements -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - s->properties.limits.bufferImageGranularity = 131072; - s->properties.limits.discreteQueuePriorities = 2; - s->properties.limits.framebufferColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.framebufferDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.framebufferNoAttachmentsSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.framebufferStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.lineWidthGranularity = 1.0f; - s->properties.limits.lineWidthRange[0] = 1.0f; - s->properties.limits.lineWidthRange[1] = 1.0f; - s->properties.limits.maxBoundDescriptorSets = 4; - s->properties.limits.maxClipDistances = 0; - s->properties.limits.maxColorAttachments = 4; - s->properties.limits.maxCombinedClipAndCullDistances = 0; - s->properties.limits.maxComputeSharedMemorySize = 16384; - s->properties.limits.maxComputeWorkGroupCount[0] = 65535; - s->properties.limits.maxComputeWorkGroupCount[1] = 65535; - s->properties.limits.maxComputeWorkGroupCount[2] = 65535; - s->properties.limits.maxComputeWorkGroupInvocations = 128; - s->properties.limits.maxComputeWorkGroupSize[0] = 128; - s->properties.limits.maxComputeWorkGroupSize[1] = 128; - s->properties.limits.maxComputeWorkGroupSize[2] = 64; - s->properties.limits.maxCullDistances = 0; - s->properties.limits.maxDescriptorSetInputAttachments = 4; - s->properties.limits.maxDescriptorSetSampledImages = 96; - s->properties.limits.maxDescriptorSetSamplers = 96; - s->properties.limits.maxDescriptorSetStorageBuffers = 24; - s->properties.limits.maxDescriptorSetStorageBuffersDynamic = 4; - s->properties.limits.maxDescriptorSetStorageImages = 24; - s->properties.limits.maxDescriptorSetUniformBuffers = 72; - s->properties.limits.maxDescriptorSetUniformBuffersDynamic = 8; - s->properties.limits.maxDrawIndexedIndexValue = 16777216; - s->properties.limits.maxDrawIndirectCount = 1; - s->properties.limits.maxFragmentCombinedOutputResources = 4; - s->properties.limits.maxFragmentDualSrcAttachments = 0; - s->properties.limits.maxFragmentInputComponents = 64; - s->properties.limits.maxFragmentOutputAttachments = 4; - s->properties.limits.maxFramebufferHeight = 4096; - s->properties.limits.maxFramebufferLayers = 256; - s->properties.limits.maxFramebufferWidth = 4096; - s->properties.limits.maxGeometryInputComponents = 0; - s->properties.limits.maxGeometryOutputComponents = 0; - s->properties.limits.maxGeometryOutputVertices = 0; - s->properties.limits.maxGeometryShaderInvocations = 0; - s->properties.limits.maxGeometryTotalOutputComponents = 0; - s->properties.limits.maxImageArrayLayers = 256; - s->properties.limits.maxImageDimension1D = 4096; - s->properties.limits.maxImageDimension2D = 4096; - s->properties.limits.maxImageDimension3D = 256; - s->properties.limits.maxImageDimensionCube = 4096; - s->properties.limits.maxInterpolationOffset = 0.0f; - s->properties.limits.maxMemoryAllocationCount = 4096; - s->properties.limits.maxPerStageDescriptorInputAttachments = 4; - s->properties.limits.maxPerStageDescriptorSampledImages = 16; - s->properties.limits.maxPerStageDescriptorSamplers = 16; - s->properties.limits.maxPerStageDescriptorStorageBuffers = 4; - s->properties.limits.maxPerStageDescriptorStorageImages = 4; - s->properties.limits.maxPerStageDescriptorUniformBuffers = 12; - s->properties.limits.maxPerStageResources = 128; - s->properties.limits.maxPushConstantsSize = 128; - s->properties.limits.maxSampleMaskWords = 1; - s->properties.limits.maxSamplerAllocationCount = 4000; - s->properties.limits.maxSamplerAnisotropy = 1; - s->properties.limits.maxSamplerLodBias = 2; - s->properties.limits.maxStorageBufferRange = 134217728; - s->properties.limits.maxTessellationControlPerPatchOutputComponents = 0; - s->properties.limits.maxTessellationControlPerVertexInputComponents = 0; - s->properties.limits.maxTessellationControlPerVertexOutputComponents = 0; - s->properties.limits.maxTessellationControlTotalOutputComponents = 0; - s->properties.limits.maxTessellationEvaluationInputComponents = 0; - s->properties.limits.maxTessellationEvaluationOutputComponents = 0; - s->properties.limits.maxTessellationGenerationLevel = 0; - s->properties.limits.maxTessellationPatchSize = 0; - s->properties.limits.maxTexelBufferElements = 65536; - s->properties.limits.maxTexelGatherOffset = 7; - s->properties.limits.maxTexelOffset = 7; - s->properties.limits.maxUniformBufferRange = 16384; - s->properties.limits.maxVertexInputAttributeOffset = 2047; - s->properties.limits.maxVertexInputAttributes = 16; - s->properties.limits.maxVertexInputBindingStride = 2048; - s->properties.limits.maxVertexInputBindings = 16; - s->properties.limits.maxVertexOutputComponents = 64; - s->properties.limits.maxViewportDimensions[0] = 4096; - s->properties.limits.maxViewportDimensions[1] = 4096; - s->properties.limits.maxViewports = 1; - s->properties.limits.minInterpolationOffset = 0.0f; - s->properties.limits.minMemoryMapAlignment = 64; - s->properties.limits.minStorageBufferOffsetAlignment = 256; - s->properties.limits.minTexelBufferOffsetAlignment = 256; - s->properties.limits.minTexelGatherOffset = -8; - s->properties.limits.minTexelOffset = -8; - s->properties.limits.minUniformBufferOffsetAlignment = 256; - s->properties.limits.mipmapPrecisionBits = 4; - s->properties.limits.nonCoherentAtomSize = 256; - s->properties.limits.pointSizeGranularity = 1.0f; - s->properties.limits.pointSizeRange[0] = 1.0f; - s->properties.limits.pointSizeRange[1] = 1.0f; - s->properties.limits.sampledImageColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sampledImageDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sampledImageIntegerSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sampledImageStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sparseAddressSpaceSize = 0; - s->properties.limits.storageImageSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); - s->properties.limits.subPixelInterpolationOffsetBits = 0; - s->properties.limits.subPixelPrecisionBits = 4; - s->properties.limits.subTexelPrecisionBits = 4; - s->properties.limits.viewportBoundsRange[0] = -8192; - s->properties.limits.viewportBoundsRange[1] = 8192; - s->properties.limits.viewportSubPixelBits = 0; - s->properties.sparseProperties.residencyNonResidentStrict = VK_FALSE; - s->properties.sparseProperties.residencyStandard2DBlockShape = VK_FALSE; - s->properties.sparseProperties.residencyStandard2DMultisampleBlockShape = VK_FALSE; - s->properties.sparseProperties.residencyStandard3DBlockShape = VK_FALSE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->properties.limits.bufferImageGranularity <= 131072); - ret = ret && ((131072 % s->properties.limits.bufferImageGranularity) == 0); - ret = ret && (s->properties.limits.discreteQueuePriorities >= 2); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (s->properties.limits.lineWidthGranularity <= 1.0); - ret = ret && (isMultiple(1.0, s->properties.limits.lineWidthGranularity)); - ret = ret && (s->properties.limits.lineWidthRange[0] <= 1.0); - ret = ret && (s->properties.limits.lineWidthRange[1] >= 1.0); - ret = ret && (s->properties.limits.maxBoundDescriptorSets >= 4); - ret = ret && (s->properties.limits.maxClipDistances >= 0); - ret = ret && (s->properties.limits.maxColorAttachments >= 4); - ret = ret && (s->properties.limits.maxCombinedClipAndCullDistances >= 0); - ret = ret && (s->properties.limits.maxComputeSharedMemorySize >= 16384); - ret = ret && (s->properties.limits.maxComputeWorkGroupCount[0] >= 65535); - ret = ret && (s->properties.limits.maxComputeWorkGroupCount[1] >= 65535); - ret = ret && (s->properties.limits.maxComputeWorkGroupCount[2] >= 65535); - ret = ret && (s->properties.limits.maxComputeWorkGroupInvocations >= 128); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[0] >= 128); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[1] >= 128); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[2] >= 64); - ret = ret && (s->properties.limits.maxCullDistances >= 0); - ret = ret && (s->properties.limits.maxDescriptorSetInputAttachments >= 4); - ret = ret && (s->properties.limits.maxDescriptorSetSampledImages >= 96); - ret = ret && (s->properties.limits.maxDescriptorSetSamplers >= 96); - ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffers >= 24); - ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4); - ret = ret && (s->properties.limits.maxDescriptorSetStorageImages >= 24); - ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffers >= 72); - ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8); - ret = ret && (s->properties.limits.maxDrawIndexedIndexValue >= 16777216); - ret = ret && (s->properties.limits.maxDrawIndirectCount >= 1); - ret = ret && (s->properties.limits.maxFragmentCombinedOutputResources >= 4); - ret = ret && (s->properties.limits.maxFragmentDualSrcAttachments >= 0); - ret = ret && (s->properties.limits.maxFragmentInputComponents >= 64); - ret = ret && (s->properties.limits.maxFragmentOutputAttachments >= 4); - ret = ret && (s->properties.limits.maxFramebufferHeight >= 4096); - ret = ret && (s->properties.limits.maxFramebufferLayers >= 256); - ret = ret && (s->properties.limits.maxFramebufferWidth >= 4096); - ret = ret && (s->properties.limits.maxGeometryInputComponents >= 0); - ret = ret && (s->properties.limits.maxGeometryOutputComponents >= 0); - ret = ret && (s->properties.limits.maxGeometryOutputVertices >= 0); - ret = ret && (s->properties.limits.maxGeometryShaderInvocations >= 0); - ret = ret && (s->properties.limits.maxGeometryTotalOutputComponents >= 0); - ret = ret && (s->properties.limits.maxImageArrayLayers >= 256); - ret = ret && (s->properties.limits.maxImageDimension1D >= 4096); - ret = ret && (s->properties.limits.maxImageDimension2D >= 4096); - ret = ret && (s->properties.limits.maxImageDimension3D >= 256); - ret = ret && (s->properties.limits.maxImageDimensionCube >= 4096); - ret = ret && (s->properties.limits.maxInterpolationOffset >= 0.0); - ret = ret && (s->properties.limits.maxMemoryAllocationCount >= 4096); - ret = ret && (s->properties.limits.maxPerStageDescriptorInputAttachments >= 4); - ret = ret && (s->properties.limits.maxPerStageDescriptorSampledImages >= 16); - ret = ret && (s->properties.limits.maxPerStageDescriptorSamplers >= 16); - ret = ret && (s->properties.limits.maxPerStageDescriptorStorageBuffers >= 4); - ret = ret && (s->properties.limits.maxPerStageDescriptorStorageImages >= 4); - ret = ret && (s->properties.limits.maxPerStageDescriptorUniformBuffers >= 12); - ret = ret && (s->properties.limits.maxPerStageResources >= 128); - ret = ret && (s->properties.limits.maxPushConstantsSize >= 128); - ret = ret && (s->properties.limits.maxSampleMaskWords >= 1); - ret = ret && (s->properties.limits.maxSamplerAllocationCount >= 4000); - ret = ret && (s->properties.limits.maxSamplerAnisotropy >= 1); - ret = ret && (s->properties.limits.maxSamplerLodBias >= 2); - ret = ret && (s->properties.limits.maxStorageBufferRange >= 134217728); - ret = ret && (s->properties.limits.maxTessellationControlPerPatchOutputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationControlPerVertexInputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationControlPerVertexOutputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationControlTotalOutputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationEvaluationInputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationEvaluationOutputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationGenerationLevel >= 0); - ret = ret && (s->properties.limits.maxTessellationPatchSize >= 0); - ret = ret && (s->properties.limits.maxTexelBufferElements >= 65536); - ret = ret && (s->properties.limits.maxTexelGatherOffset >= 7); - ret = ret && (s->properties.limits.maxTexelOffset >= 7); - ret = ret && (s->properties.limits.maxUniformBufferRange >= 16384); - ret = ret && (s->properties.limits.maxVertexInputAttributeOffset >= 2047); - ret = ret && (s->properties.limits.maxVertexInputAttributes >= 16); - ret = ret && (s->properties.limits.maxVertexInputBindingStride >= 2048); - ret = ret && (s->properties.limits.maxVertexInputBindings >= 16); - ret = ret && (s->properties.limits.maxVertexOutputComponents >= 64); - ret = ret && (s->properties.limits.maxViewportDimensions[0] >= 4096); - ret = ret && (s->properties.limits.maxViewportDimensions[1] >= 4096); - ret = ret && (s->properties.limits.maxViewports >= 1); - ret = ret && (s->properties.limits.minInterpolationOffset <= 0.0); - ret = ret && (s->properties.limits.minMemoryMapAlignment <= 64); - ret = ret && ((s->properties.limits.minMemoryMapAlignment & (s->properties.limits.minMemoryMapAlignment - 1)) == 0); - ret = ret && (s->properties.limits.minStorageBufferOffsetAlignment <= 256); - ret = ret && ((s->properties.limits.minStorageBufferOffsetAlignment & (s->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0); - ret = ret && (s->properties.limits.minTexelBufferOffsetAlignment <= 256); - ret = ret && ((s->properties.limits.minTexelBufferOffsetAlignment & (s->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0); - ret = ret && (s->properties.limits.minTexelGatherOffset <= -8); - ret = ret && (s->properties.limits.minTexelOffset <= -8); - ret = ret && (s->properties.limits.minUniformBufferOffsetAlignment <= 256); - ret = ret && ((s->properties.limits.minUniformBufferOffsetAlignment & (s->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0); - ret = ret && (s->properties.limits.mipmapPrecisionBits >= 4); - ret = ret && (s->properties.limits.nonCoherentAtomSize <= 256); - ret = ret && ((s->properties.limits.nonCoherentAtomSize & (s->properties.limits.nonCoherentAtomSize - 1)) == 0); - ret = ret && (s->properties.limits.pointSizeGranularity <= 1.0); - ret = ret && (isMultiple(1.0, s->properties.limits.pointSizeGranularity)); - ret = ret && (s->properties.limits.pointSizeRange[0] <= 1.0); - ret = ret && (s->properties.limits.pointSizeRange[1] >= 1.0); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (s->properties.limits.sparseAddressSpaceSize >= 0); - ret = ret && (vpCheckFlags(s->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); - ret = ret && (s->properties.limits.subPixelInterpolationOffsetBits >= 0); - ret = ret && (s->properties.limits.subPixelPrecisionBits >= 4); - ret = ret && (s->properties.limits.subTexelPrecisionBits >= 4); - ret = ret && (s->properties.limits.viewportBoundsRange[0] <= -8192); - ret = ret && (s->properties.limits.viewportBoundsRange[1] >= 8192); - ret = ret && (s->properties.limits.viewportSubPixelBits >= 0); - ret = ret && (vpCheckFlags(s->properties.sparseProperties.residencyNonResidentStrict, VK_FALSE)); - ret = ret && (vpCheckFlags(s->properties.sparseProperties.residencyStandard2DBlockShape, VK_FALSE)); - ret = ret && (vpCheckFlags(s->properties.sparseProperties.residencyStandard2DMultisampleBlockShape, VK_FALSE)); - ret = ret && (vpCheckFlags(s->properties.sparseProperties.residencyStandard3DBlockShape, VK_FALSE)); - } break; - default: break; - } - return ret; - } +namespace vulkan12requirements_roadmap2022 +{ +static const VpVariantDesc variants[] = { + { + "vulkan12requirements_roadmap2022", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan12requirements_roadmap2022::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::vulkan12requirements_roadmap2022::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan12requirements_roadmap2022::chainerDesc, + 0, + nullptr, + }, }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan12requirements_roadmap2022 -static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - p->pNext = static_cast(static_cast(nullptr)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - p->pNext = static_cast(static_cast(nullptr)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); +namespace vulkan13requirements +{ +static const VpVariantDesc variants[] = { + { + "vulkan13requirements", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan13requirements::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::vulkan13requirements::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan13requirements::chainerDesc, + 0, + nullptr, }, }; -} //namespace vulkan10requirements -} // namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_0 -#endif // VP_LUNARG_minimum_requirements_1_0 - -#ifdef VP_LUNARG_minimum_requirements_1_1 -namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_1 { +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan13requirements -static const VkStructureType featureStructTypes[] = { - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, +namespace vulkan13requirements_roadmap2022 +{ +static const VpVariantDesc variants[] = { + { + "vulkan13requirements_roadmap2022", + 0, + nullptr, + static_cast(std::size(blocks::vulkan13requirements_roadmap2022::deviceExtensions)), + blocks::vulkan13requirements_roadmap2022::deviceExtensions, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan13requirements_roadmap2022::featureDesc, + 0, + nullptr, + blocks::vulkan13requirements_roadmap2022::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan13requirements_roadmap2022::chainerDesc, + 0, + nullptr, + }, }; - -static const VkStructureType propertyStructTypes[] = { - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan13requirements_roadmap2022 +} // namespace blocks + +static const VpCapabilitiesDesc capabilities[] = { + {blocks::vulkan10requirements::variantCount, blocks::vulkan10requirements::variants}, + {blocks::vulkan10requirements_roadmap2022::variantCount, blocks::vulkan10requirements_roadmap2022::variants}, + {blocks::vulkan11requirements::variantCount, blocks::vulkan11requirements::variants}, + {blocks::vulkan11requirements_roadmap2022::variantCount, blocks::vulkan11requirements_roadmap2022::variants}, + {blocks::vulkan12requirements::variantCount, blocks::vulkan12requirements::variants}, + {blocks::vulkan12requirements_roadmap2022::variantCount, blocks::vulkan12requirements_roadmap2022::variants}, + {blocks::vulkan13requirements::variantCount, blocks::vulkan13requirements::variants}, + {blocks::vulkan13requirements_roadmap2022::variantCount, blocks::vulkan13requirements_roadmap2022::variants}, }; +static const uint32_t capabilityCount = static_cast(std::size(capabilities)); +} // namespace VP_KHR_ROADMAP_2022 +#endif // VP_KHR_roadmap_2022 -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.robustBufferAccess = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: { - VkPhysicalDeviceMultiviewFeatures* s = static_cast(static_cast(p)); - s->multiview = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.robustBufferAccess == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: { - VkPhysicalDeviceMultiviewFeatures* s = static_cast(static_cast(p)); - ret = ret && (s->multiview == VK_TRUE); - } break; - default: break; - } - return ret; - } +#ifdef VP_KHR_roadmap_2024 +namespace VP_KHR_ROADMAP_2024 +{ +static const VpVariantDesc mergedCapabilities[] = { + { + "MERGED", + 0, + nullptr, + static_cast(std::size(deviceExtensions)), + deviceExtensions, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + featureDesc, + 0, + nullptr, + propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + chainerDesc, + 0, + nullptr, + }, }; -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; +namespace blocks +{ +namespace vulkan10requirements_roadmap2024 +{ +static const VpVariantDesc variants[] = { + { + "vulkan10requirements_roadmap2024", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan10requirements_roadmap2024::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::vulkan10requirements_roadmap2024::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan10requirements_roadmap2024::chainerDesc, + 0, + nullptr, }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan10requirements_roadmap2024 -static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceMultiviewFeatures physicalDeviceMultiviewFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, nullptr }; - p->pNext = static_cast(static_cast(&physicalDeviceMultiviewFeatures)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceSubgroupProperties physicalDeviceSubgroupProperties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, nullptr }; - VkPhysicalDeviceMultiviewProperties physicalDeviceMultiviewProperties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, &physicalDeviceSubgroupProperties }; - VkPhysicalDeviceMaintenance3Properties physicalDeviceMaintenance3Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, &physicalDeviceMultiviewProperties }; - p->pNext = static_cast(static_cast(&physicalDeviceMaintenance3Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); +namespace vulkan11requirements_roadmap2024 +{ +static const VpVariantDesc variants[] = { + { + "vulkan11requirements_roadmap2024", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan11requirements_roadmap2024::featureDesc, + 0, + nullptr, + blocks::vulkan11requirements_roadmap2024::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan11requirements_roadmap2024::chainerDesc, + 0, + nullptr, }, }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan11requirements_roadmap2024 -namespace vulkan10requirements { -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.robustBufferAccess = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.robustBufferAccess == VK_TRUE); - } break; - default: break; - } - return ret; - } +namespace vulkan12requirements_roadmap2024 +{ +static const VpVariantDesc variants[] = { + { + "vulkan12requirements_roadmap2024", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan12requirements_roadmap2024::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::vulkan12requirements_roadmap2024::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan12requirements_roadmap2024::chainerDesc, + 0, + nullptr, + }, }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan12requirements_roadmap2024 -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - s->properties.limits.bufferImageGranularity = 131072; - s->properties.limits.discreteQueuePriorities = 2; - s->properties.limits.framebufferColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.framebufferDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.framebufferNoAttachmentsSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.framebufferStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.lineWidthGranularity = 1.0f; - s->properties.limits.lineWidthRange[0] = 1.0f; - s->properties.limits.lineWidthRange[1] = 1.0f; - s->properties.limits.maxBoundDescriptorSets = 4; - s->properties.limits.maxClipDistances = 0; - s->properties.limits.maxColorAttachments = 4; - s->properties.limits.maxCombinedClipAndCullDistances = 0; - s->properties.limits.maxComputeSharedMemorySize = 16384; - s->properties.limits.maxComputeWorkGroupCount[0] = 65535; - s->properties.limits.maxComputeWorkGroupCount[1] = 65535; - s->properties.limits.maxComputeWorkGroupCount[2] = 65535; - s->properties.limits.maxComputeWorkGroupInvocations = 128; - s->properties.limits.maxComputeWorkGroupSize[0] = 128; - s->properties.limits.maxComputeWorkGroupSize[1] = 128; - s->properties.limits.maxComputeWorkGroupSize[2] = 64; - s->properties.limits.maxCullDistances = 0; - s->properties.limits.maxDescriptorSetInputAttachments = 4; - s->properties.limits.maxDescriptorSetSampledImages = 96; - s->properties.limits.maxDescriptorSetSamplers = 96; - s->properties.limits.maxDescriptorSetStorageBuffers = 24; - s->properties.limits.maxDescriptorSetStorageBuffersDynamic = 4; - s->properties.limits.maxDescriptorSetStorageImages = 24; - s->properties.limits.maxDescriptorSetUniformBuffers = 72; - s->properties.limits.maxDescriptorSetUniformBuffersDynamic = 8; - s->properties.limits.maxDrawIndexedIndexValue = 16777216; - s->properties.limits.maxDrawIndirectCount = 1; - s->properties.limits.maxFragmentCombinedOutputResources = 4; - s->properties.limits.maxFragmentDualSrcAttachments = 0; - s->properties.limits.maxFragmentInputComponents = 64; - s->properties.limits.maxFragmentOutputAttachments = 4; - s->properties.limits.maxFramebufferHeight = 4096; - s->properties.limits.maxFramebufferLayers = 256; - s->properties.limits.maxFramebufferWidth = 4096; - s->properties.limits.maxGeometryInputComponents = 0; - s->properties.limits.maxGeometryOutputComponents = 0; - s->properties.limits.maxGeometryOutputVertices = 0; - s->properties.limits.maxGeometryShaderInvocations = 0; - s->properties.limits.maxGeometryTotalOutputComponents = 0; - s->properties.limits.maxImageArrayLayers = 256; - s->properties.limits.maxImageDimension1D = 4096; - s->properties.limits.maxImageDimension2D = 4096; - s->properties.limits.maxImageDimension3D = 256; - s->properties.limits.maxImageDimensionCube = 4096; - s->properties.limits.maxInterpolationOffset = 0.0f; - s->properties.limits.maxMemoryAllocationCount = 4096; - s->properties.limits.maxPerStageDescriptorInputAttachments = 4; - s->properties.limits.maxPerStageDescriptorSampledImages = 16; - s->properties.limits.maxPerStageDescriptorSamplers = 16; - s->properties.limits.maxPerStageDescriptorStorageBuffers = 4; - s->properties.limits.maxPerStageDescriptorStorageImages = 4; - s->properties.limits.maxPerStageDescriptorUniformBuffers = 12; - s->properties.limits.maxPerStageResources = 128; - s->properties.limits.maxPushConstantsSize = 128; - s->properties.limits.maxSampleMaskWords = 1; - s->properties.limits.maxSamplerAllocationCount = 4000; - s->properties.limits.maxSamplerAnisotropy = 1; - s->properties.limits.maxSamplerLodBias = 2; - s->properties.limits.maxStorageBufferRange = 134217728; - s->properties.limits.maxTessellationControlPerPatchOutputComponents = 0; - s->properties.limits.maxTessellationControlPerVertexInputComponents = 0; - s->properties.limits.maxTessellationControlPerVertexOutputComponents = 0; - s->properties.limits.maxTessellationControlTotalOutputComponents = 0; - s->properties.limits.maxTessellationEvaluationInputComponents = 0; - s->properties.limits.maxTessellationEvaluationOutputComponents = 0; - s->properties.limits.maxTessellationGenerationLevel = 0; - s->properties.limits.maxTessellationPatchSize = 0; - s->properties.limits.maxTexelBufferElements = 65536; - s->properties.limits.maxTexelGatherOffset = 7; - s->properties.limits.maxTexelOffset = 7; - s->properties.limits.maxUniformBufferRange = 16384; - s->properties.limits.maxVertexInputAttributeOffset = 2047; - s->properties.limits.maxVertexInputAttributes = 16; - s->properties.limits.maxVertexInputBindingStride = 2048; - s->properties.limits.maxVertexInputBindings = 16; - s->properties.limits.maxVertexOutputComponents = 64; - s->properties.limits.maxViewportDimensions[0] = 4096; - s->properties.limits.maxViewportDimensions[1] = 4096; - s->properties.limits.maxViewports = 1; - s->properties.limits.minInterpolationOffset = 0.0f; - s->properties.limits.minMemoryMapAlignment = 64; - s->properties.limits.minStorageBufferOffsetAlignment = 256; - s->properties.limits.minTexelBufferOffsetAlignment = 256; - s->properties.limits.minTexelGatherOffset = -8; - s->properties.limits.minTexelOffset = -8; - s->properties.limits.minUniformBufferOffsetAlignment = 256; - s->properties.limits.mipmapPrecisionBits = 4; - s->properties.limits.nonCoherentAtomSize = 256; - s->properties.limits.pointSizeGranularity = 1.0f; - s->properties.limits.pointSizeRange[0] = 1.0f; - s->properties.limits.pointSizeRange[1] = 1.0f; - s->properties.limits.sampledImageColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sampledImageDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sampledImageIntegerSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sampledImageStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sparseAddressSpaceSize = 0; - s->properties.limits.storageImageSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); - s->properties.limits.subPixelInterpolationOffsetBits = 0; - s->properties.limits.subPixelPrecisionBits = 4; - s->properties.limits.subTexelPrecisionBits = 4; - s->properties.limits.viewportBoundsRange[0] = -8192; - s->properties.limits.viewportBoundsRange[1] = 8192; - s->properties.limits.viewportSubPixelBits = 0; - s->properties.sparseProperties.residencyNonResidentStrict = VK_FALSE; - s->properties.sparseProperties.residencyStandard2DBlockShape = VK_FALSE; - s->properties.sparseProperties.residencyStandard2DMultisampleBlockShape = VK_FALSE; - s->properties.sparseProperties.residencyStandard3DBlockShape = VK_FALSE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->properties.limits.bufferImageGranularity <= 131072); - ret = ret && ((131072 % s->properties.limits.bufferImageGranularity) == 0); - ret = ret && (s->properties.limits.discreteQueuePriorities >= 2); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (s->properties.limits.lineWidthGranularity <= 1.0); - ret = ret && (isMultiple(1.0, s->properties.limits.lineWidthGranularity)); - ret = ret && (s->properties.limits.lineWidthRange[0] <= 1.0); - ret = ret && (s->properties.limits.lineWidthRange[1] >= 1.0); - ret = ret && (s->properties.limits.maxBoundDescriptorSets >= 4); - ret = ret && (s->properties.limits.maxClipDistances >= 0); - ret = ret && (s->properties.limits.maxColorAttachments >= 4); - ret = ret && (s->properties.limits.maxCombinedClipAndCullDistances >= 0); - ret = ret && (s->properties.limits.maxComputeSharedMemorySize >= 16384); - ret = ret && (s->properties.limits.maxComputeWorkGroupCount[0] >= 65535); - ret = ret && (s->properties.limits.maxComputeWorkGroupCount[1] >= 65535); - ret = ret && (s->properties.limits.maxComputeWorkGroupCount[2] >= 65535); - ret = ret && (s->properties.limits.maxComputeWorkGroupInvocations >= 128); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[0] >= 128); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[1] >= 128); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[2] >= 64); - ret = ret && (s->properties.limits.maxCullDistances >= 0); - ret = ret && (s->properties.limits.maxDescriptorSetInputAttachments >= 4); - ret = ret && (s->properties.limits.maxDescriptorSetSampledImages >= 96); - ret = ret && (s->properties.limits.maxDescriptorSetSamplers >= 96); - ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffers >= 24); - ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4); - ret = ret && (s->properties.limits.maxDescriptorSetStorageImages >= 24); - ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffers >= 72); - ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8); - ret = ret && (s->properties.limits.maxDrawIndexedIndexValue >= 16777216); - ret = ret && (s->properties.limits.maxDrawIndirectCount >= 1); - ret = ret && (s->properties.limits.maxFragmentCombinedOutputResources >= 4); - ret = ret && (s->properties.limits.maxFragmentDualSrcAttachments >= 0); - ret = ret && (s->properties.limits.maxFragmentInputComponents >= 64); - ret = ret && (s->properties.limits.maxFragmentOutputAttachments >= 4); - ret = ret && (s->properties.limits.maxFramebufferHeight >= 4096); - ret = ret && (s->properties.limits.maxFramebufferLayers >= 256); - ret = ret && (s->properties.limits.maxFramebufferWidth >= 4096); - ret = ret && (s->properties.limits.maxGeometryInputComponents >= 0); - ret = ret && (s->properties.limits.maxGeometryOutputComponents >= 0); - ret = ret && (s->properties.limits.maxGeometryOutputVertices >= 0); - ret = ret && (s->properties.limits.maxGeometryShaderInvocations >= 0); - ret = ret && (s->properties.limits.maxGeometryTotalOutputComponents >= 0); - ret = ret && (s->properties.limits.maxImageArrayLayers >= 256); - ret = ret && (s->properties.limits.maxImageDimension1D >= 4096); - ret = ret && (s->properties.limits.maxImageDimension2D >= 4096); - ret = ret && (s->properties.limits.maxImageDimension3D >= 256); - ret = ret && (s->properties.limits.maxImageDimensionCube >= 4096); - ret = ret && (s->properties.limits.maxInterpolationOffset >= 0.0); - ret = ret && (s->properties.limits.maxMemoryAllocationCount >= 4096); - ret = ret && (s->properties.limits.maxPerStageDescriptorInputAttachments >= 4); - ret = ret && (s->properties.limits.maxPerStageDescriptorSampledImages >= 16); - ret = ret && (s->properties.limits.maxPerStageDescriptorSamplers >= 16); - ret = ret && (s->properties.limits.maxPerStageDescriptorStorageBuffers >= 4); - ret = ret && (s->properties.limits.maxPerStageDescriptorStorageImages >= 4); - ret = ret && (s->properties.limits.maxPerStageDescriptorUniformBuffers >= 12); - ret = ret && (s->properties.limits.maxPerStageResources >= 128); - ret = ret && (s->properties.limits.maxPushConstantsSize >= 128); - ret = ret && (s->properties.limits.maxSampleMaskWords >= 1); - ret = ret && (s->properties.limits.maxSamplerAllocationCount >= 4000); - ret = ret && (s->properties.limits.maxSamplerAnisotropy >= 1); - ret = ret && (s->properties.limits.maxSamplerLodBias >= 2); - ret = ret && (s->properties.limits.maxStorageBufferRange >= 134217728); - ret = ret && (s->properties.limits.maxTessellationControlPerPatchOutputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationControlPerVertexInputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationControlPerVertexOutputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationControlTotalOutputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationEvaluationInputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationEvaluationOutputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationGenerationLevel >= 0); - ret = ret && (s->properties.limits.maxTessellationPatchSize >= 0); - ret = ret && (s->properties.limits.maxTexelBufferElements >= 65536); - ret = ret && (s->properties.limits.maxTexelGatherOffset >= 7); - ret = ret && (s->properties.limits.maxTexelOffset >= 7); - ret = ret && (s->properties.limits.maxUniformBufferRange >= 16384); - ret = ret && (s->properties.limits.maxVertexInputAttributeOffset >= 2047); - ret = ret && (s->properties.limits.maxVertexInputAttributes >= 16); - ret = ret && (s->properties.limits.maxVertexInputBindingStride >= 2048); - ret = ret && (s->properties.limits.maxVertexInputBindings >= 16); - ret = ret && (s->properties.limits.maxVertexOutputComponents >= 64); - ret = ret && (s->properties.limits.maxViewportDimensions[0] >= 4096); - ret = ret && (s->properties.limits.maxViewportDimensions[1] >= 4096); - ret = ret && (s->properties.limits.maxViewports >= 1); - ret = ret && (s->properties.limits.minInterpolationOffset <= 0.0); - ret = ret && (s->properties.limits.minMemoryMapAlignment <= 64); - ret = ret && ((s->properties.limits.minMemoryMapAlignment & (s->properties.limits.minMemoryMapAlignment - 1)) == 0); - ret = ret && (s->properties.limits.minStorageBufferOffsetAlignment <= 256); - ret = ret && ((s->properties.limits.minStorageBufferOffsetAlignment & (s->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0); - ret = ret && (s->properties.limits.minTexelBufferOffsetAlignment <= 256); - ret = ret && ((s->properties.limits.minTexelBufferOffsetAlignment & (s->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0); - ret = ret && (s->properties.limits.minTexelGatherOffset <= -8); - ret = ret && (s->properties.limits.minTexelOffset <= -8); - ret = ret && (s->properties.limits.minUniformBufferOffsetAlignment <= 256); - ret = ret && ((s->properties.limits.minUniformBufferOffsetAlignment & (s->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0); - ret = ret && (s->properties.limits.mipmapPrecisionBits >= 4); - ret = ret && (s->properties.limits.nonCoherentAtomSize <= 256); - ret = ret && ((s->properties.limits.nonCoherentAtomSize & (s->properties.limits.nonCoherentAtomSize - 1)) == 0); - ret = ret && (s->properties.limits.pointSizeGranularity <= 1.0); - ret = ret && (isMultiple(1.0, s->properties.limits.pointSizeGranularity)); - ret = ret && (s->properties.limits.pointSizeRange[0] <= 1.0); - ret = ret && (s->properties.limits.pointSizeRange[1] >= 1.0); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (s->properties.limits.sparseAddressSpaceSize >= 0); - ret = ret && (vpCheckFlags(s->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); - ret = ret && (s->properties.limits.subPixelInterpolationOffsetBits >= 0); - ret = ret && (s->properties.limits.subPixelPrecisionBits >= 4); - ret = ret && (s->properties.limits.subTexelPrecisionBits >= 4); - ret = ret && (s->properties.limits.viewportBoundsRange[0] <= -8192); - ret = ret && (s->properties.limits.viewportBoundsRange[1] >= 8192); - ret = ret && (s->properties.limits.viewportSubPixelBits >= 0); - ret = ret && (vpCheckFlags(s->properties.sparseProperties.residencyNonResidentStrict, VK_FALSE)); - ret = ret && (vpCheckFlags(s->properties.sparseProperties.residencyStandard2DBlockShape, VK_FALSE)); - ret = ret && (vpCheckFlags(s->properties.sparseProperties.residencyStandard2DMultisampleBlockShape, VK_FALSE)); - ret = ret && (vpCheckFlags(s->properties.sparseProperties.residencyStandard3DBlockShape, VK_FALSE)); - } break; - default: break; - } - return ret; - } +namespace vulkan13requirements_roadmap2024 +{ +static const VpVariantDesc variants[] = { + { + "vulkan13requirements_roadmap2024", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan13requirements_roadmap2024::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::vulkan13requirements_roadmap2024::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan13requirements_roadmap2024::chainerDesc, + 0, + nullptr, + }, }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan13requirements_roadmap2024 -static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceMultiviewFeatures physicalDeviceMultiviewFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, nullptr }; - p->pNext = static_cast(static_cast(&physicalDeviceMultiviewFeatures)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceSubgroupProperties physicalDeviceSubgroupProperties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, nullptr }; - VkPhysicalDeviceMultiviewProperties physicalDeviceMultiviewProperties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, &physicalDeviceSubgroupProperties }; - VkPhysicalDeviceMaintenance3Properties physicalDeviceMaintenance3Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, &physicalDeviceMultiviewProperties }; - p->pNext = static_cast(static_cast(&physicalDeviceMaintenance3Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); +namespace vulkanextensionrequirements_roadmap2024 +{ +static const VpVariantDesc variants[] = { + { + "vulkanextensionrequirements_roadmap2024", + 0, + nullptr, + static_cast(std::size(blocks::vulkanextensionrequirements_roadmap2024::deviceExtensions)), + blocks::vulkanextensionrequirements_roadmap2024::deviceExtensions, + 0, + nullptr, + blocks::vulkanextensionrequirements_roadmap2024::featureDesc, + 0, + nullptr, + blocks::vulkanextensionrequirements_roadmap2024::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkanextensionrequirements_roadmap2024::chainerDesc, + 0, + nullptr, }, }; -} //namespace vulkan10requirements -namespace vulkan11requirements_split { -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: { - VkPhysicalDeviceMultiviewFeatures* s = static_cast(static_cast(p)); - s->multiview = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: { - VkPhysicalDeviceMultiviewFeatures* s = static_cast(static_cast(p)); - ret = ret && (s->multiview == VK_TRUE); - } break; - default: break; - } - return ret; - } +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkanextensionrequirements_roadmap2024 +} // namespace blocks + +static const VpCapabilitiesDesc capabilities[] = { + {blocks::vulkan10requirements_roadmap2024::variantCount, blocks::vulkan10requirements_roadmap2024::variants}, + {blocks::vulkan11requirements_roadmap2024::variantCount, blocks::vulkan11requirements_roadmap2024::variants}, + {blocks::vulkan12requirements_roadmap2024::variantCount, blocks::vulkan12requirements_roadmap2024::variants}, + {blocks::vulkan13requirements_roadmap2024::variantCount, blocks::vulkan13requirements_roadmap2024::variants}, + {blocks::vulkanextensionrequirements_roadmap2024::variantCount, blocks::vulkanextensionrequirements_roadmap2024::variants}, }; +static const uint32_t capabilityCount = static_cast(std::size(capabilities)); -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: { - VkPhysicalDeviceSubgroupProperties* s = static_cast(static_cast(p)); - s->subgroupSize = 1; - s->supportedOperations |= (VK_SUBGROUP_FEATURE_BASIC_BIT); - s->supportedStages |= (VK_SHADER_STAGE_COMPUTE_BIT); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: { - VkPhysicalDeviceMultiviewProperties* s = static_cast(static_cast(p)); - s->maxMultiviewInstanceIndex = 134217727; - s->maxMultiviewViewCount = 6; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: { - VkPhysicalDeviceMaintenance3Properties* s = static_cast(static_cast(p)); - s->maxMemoryAllocationSize = 1073741824; - s->maxPerSetDescriptors = 1024; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: { - VkPhysicalDeviceSubgroupProperties* s = static_cast(static_cast(p)); - ret = ret && (s->subgroupSize >= 1); - ret = ret && ((s->subgroupSize & (s->subgroupSize - 1)) == 0); - ret = ret && (vpCheckFlags(s->supportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT))); - ret = ret && (vpCheckFlags(s->supportedStages, (VK_SHADER_STAGE_COMPUTE_BIT))); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: { - VkPhysicalDeviceMultiviewProperties* s = static_cast(static_cast(p)); - ret = ret && (s->maxMultiviewInstanceIndex >= 134217727); - ret = ret && (s->maxMultiviewViewCount >= 6); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: { - VkPhysicalDeviceMaintenance3Properties* s = static_cast(static_cast(p)); - ret = ret && (s->maxMemoryAllocationSize >= 1073741824); - ret = ret && (s->maxPerSetDescriptors >= 1024); - } break; - default: break; - } - return ret; - } +static const VpProfileProperties profiles[] = { + {VP_KHR_ROADMAP_2022_NAME, VP_KHR_ROADMAP_2022_SPEC_VERSION}, }; +static const uint32_t profileCount = static_cast(std::size(profiles)); +} // namespace VP_KHR_ROADMAP_2024 +#endif // VP_KHR_roadmap_2024 -static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceMultiviewFeatures physicalDeviceMultiviewFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, nullptr }; - p->pNext = static_cast(static_cast(&physicalDeviceMultiviewFeatures)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceSubgroupProperties physicalDeviceSubgroupProperties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, nullptr }; - VkPhysicalDeviceMultiviewProperties physicalDeviceMultiviewProperties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, &physicalDeviceSubgroupProperties }; - VkPhysicalDeviceMaintenance3Properties physicalDeviceMaintenance3Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, &physicalDeviceMultiviewProperties }; - p->pNext = static_cast(static_cast(&physicalDeviceMaintenance3Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); +#ifdef VP_LUNARG_desktop_baseline_2022 +namespace VP_LUNARG_DESKTOP_BASELINE_2022 +{ +static const VpVariantDesc mergedCapabilities[] = { + { + "MERGED", + 0, + nullptr, + static_cast(std::size(deviceExtensions)), + deviceExtensions, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + featureDesc, + 0, + nullptr, + propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + chainerDesc, + 0, + nullptr, }, }; -} //namespace vulkan11requirements_split -} // namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_1 -#endif // VP_LUNARG_minimum_requirements_1_1 - -#ifdef VP_LUNARG_minimum_requirements_1_2 -namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_2 { - -static const VkStructureType featureStructTypes[] = { - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, -}; -static const VkStructureType propertyStructTypes[] = { - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, +namespace blocks +{ +namespace VP_LUNARG_desktop_baseline_2022_block +{ +static const VpVariantDesc variants[] = { + { + "VP_LUNARG_desktop_baseline_2022_block", + 0, + nullptr, + static_cast(std::size(blocks::VP_LUNARG_desktop_baseline_2022_block::deviceExtensions)), + blocks::VP_LUNARG_desktop_baseline_2022_block::deviceExtensions, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::VP_LUNARG_desktop_baseline_2022_block::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::VP_LUNARG_desktop_baseline_2022_block::propertyDesc, + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(formatStructTypes)), + formatStructTypes, + static_cast(std::size(blocks::VP_LUNARG_desktop_baseline_2022_block::formatDesc)), + blocks::VP_LUNARG_desktop_baseline_2022_block::formatDesc, + blocks::VP_LUNARG_desktop_baseline_2022_block::chainerDesc, + 0, + nullptr, + }, }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace VP_LUNARG_desktop_baseline_2022_block +} // namespace blocks -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.robustBufferAccess = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceVulkan11Features* s = static_cast(static_cast(p)); - s->multiview = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - s->hostQueryReset = VK_TRUE; - s->imagelessFramebuffer = VK_TRUE; - s->separateDepthStencilLayouts = VK_TRUE; - s->shaderSubgroupExtendedTypes = VK_TRUE; - s->subgroupBroadcastDynamicId = VK_TRUE; - s->timelineSemaphore = VK_TRUE; - s->uniformBufferStandardLayout = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.robustBufferAccess == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceVulkan11Features* s = static_cast(static_cast(p)); - ret = ret && (s->multiview == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - ret = ret && (s->hostQueryReset == VK_TRUE); - ret = ret && (s->imagelessFramebuffer == VK_TRUE); - ret = ret && (s->separateDepthStencilLayouts == VK_TRUE); - ret = ret && (s->shaderSubgroupExtendedTypes == VK_TRUE); - ret = ret && (s->subgroupBroadcastDynamicId == VK_TRUE); - ret = ret && (s->timelineSemaphore == VK_TRUE); - ret = ret && (s->uniformBufferStandardLayout == VK_TRUE); - } break; - default: break; - } - return ret; - } +static const VpCapabilitiesDesc capabilities[] = { + {blocks::VP_LUNARG_desktop_baseline_2022_block::variantCount, blocks::VP_LUNARG_desktop_baseline_2022_block::variants}, }; +static const uint32_t capabilityCount = static_cast(std::size(capabilities)); +} // namespace VP_LUNARG_DESKTOP_BASELINE_2022 +#endif // VP_LUNARG_desktop_baseline_2022 -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; +#ifdef VP_LUNARG_desktop_baseline_2023 +namespace VP_LUNARG_DESKTOP_BASELINE_2023 +{ +static const VpVariantDesc mergedCapabilities[] = { + { + "MERGED", + 0, + nullptr, + static_cast(std::size(deviceExtensions)), + deviceExtensions, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + featureDesc, + 0, + nullptr, + propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + chainerDesc, + 0, + nullptr, }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } }; -static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Features)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); +namespace blocks +{ +namespace VP_LUNARG_desktop_baseline_2023_block +{ +static const VpVariantDesc variants[] = { + { + "VP_LUNARG_desktop_baseline_2023_block", + 0, + nullptr, + static_cast(std::size(blocks::VP_LUNARG_desktop_baseline_2023_block::deviceExtensions)), + blocks::VP_LUNARG_desktop_baseline_2023_block::deviceExtensions, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::VP_LUNARG_desktop_baseline_2023_block::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::VP_LUNARG_desktop_baseline_2023_block::propertyDesc, + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(formatStructTypes)), + formatStructTypes, + static_cast(std::size(blocks::VP_LUNARG_desktop_baseline_2023_block::formatDesc)), + blocks::VP_LUNARG_desktop_baseline_2023_block::formatDesc, + blocks::VP_LUNARG_desktop_baseline_2023_block::chainerDesc, + 0, + nullptr, }, }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace VP_LUNARG_desktop_baseline_2023_block +} // namespace blocks -namespace vulkan10requirements { -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.robustBufferAccess = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.robustBufferAccess == VK_TRUE); - } break; - default: break; - } - return ret; - } +static const VpCapabilitiesDesc capabilities[] = { + {blocks::VP_LUNARG_desktop_baseline_2023_block::variantCount, blocks::VP_LUNARG_desktop_baseline_2023_block::variants}, }; +static const uint32_t capabilityCount = static_cast(std::size(capabilities)); +} // namespace VP_LUNARG_DESKTOP_BASELINE_2023 +#endif // VP_LUNARG_desktop_baseline_2023 -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - s->properties.limits.bufferImageGranularity = 131072; - s->properties.limits.discreteQueuePriorities = 2; - s->properties.limits.framebufferColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.framebufferDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.framebufferNoAttachmentsSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.framebufferStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.lineWidthGranularity = 1.0f; - s->properties.limits.lineWidthRange[0] = 1.0f; - s->properties.limits.lineWidthRange[1] = 1.0f; - s->properties.limits.maxBoundDescriptorSets = 4; - s->properties.limits.maxClipDistances = 0; - s->properties.limits.maxColorAttachments = 4; - s->properties.limits.maxCombinedClipAndCullDistances = 0; - s->properties.limits.maxComputeSharedMemorySize = 16384; - s->properties.limits.maxComputeWorkGroupCount[0] = 65535; - s->properties.limits.maxComputeWorkGroupCount[1] = 65535; - s->properties.limits.maxComputeWorkGroupCount[2] = 65535; - s->properties.limits.maxComputeWorkGroupInvocations = 128; - s->properties.limits.maxComputeWorkGroupSize[0] = 128; - s->properties.limits.maxComputeWorkGroupSize[1] = 128; - s->properties.limits.maxComputeWorkGroupSize[2] = 64; - s->properties.limits.maxCullDistances = 0; - s->properties.limits.maxDescriptorSetInputAttachments = 4; - s->properties.limits.maxDescriptorSetSampledImages = 96; - s->properties.limits.maxDescriptorSetSamplers = 96; - s->properties.limits.maxDescriptorSetStorageBuffers = 24; - s->properties.limits.maxDescriptorSetStorageBuffersDynamic = 4; - s->properties.limits.maxDescriptorSetStorageImages = 24; - s->properties.limits.maxDescriptorSetUniformBuffers = 72; - s->properties.limits.maxDescriptorSetUniformBuffersDynamic = 8; - s->properties.limits.maxDrawIndexedIndexValue = 16777216; - s->properties.limits.maxDrawIndirectCount = 1; - s->properties.limits.maxFragmentCombinedOutputResources = 4; - s->properties.limits.maxFragmentDualSrcAttachments = 0; - s->properties.limits.maxFragmentInputComponents = 64; - s->properties.limits.maxFragmentOutputAttachments = 4; - s->properties.limits.maxFramebufferHeight = 4096; - s->properties.limits.maxFramebufferLayers = 256; - s->properties.limits.maxFramebufferWidth = 4096; - s->properties.limits.maxGeometryInputComponents = 0; - s->properties.limits.maxGeometryOutputComponents = 0; - s->properties.limits.maxGeometryOutputVertices = 0; - s->properties.limits.maxGeometryShaderInvocations = 0; - s->properties.limits.maxGeometryTotalOutputComponents = 0; - s->properties.limits.maxImageArrayLayers = 256; - s->properties.limits.maxImageDimension1D = 4096; - s->properties.limits.maxImageDimension2D = 4096; - s->properties.limits.maxImageDimension3D = 256; - s->properties.limits.maxImageDimensionCube = 4096; - s->properties.limits.maxInterpolationOffset = 0.0f; - s->properties.limits.maxMemoryAllocationCount = 4096; - s->properties.limits.maxPerStageDescriptorInputAttachments = 4; - s->properties.limits.maxPerStageDescriptorSampledImages = 16; - s->properties.limits.maxPerStageDescriptorSamplers = 16; - s->properties.limits.maxPerStageDescriptorStorageBuffers = 4; - s->properties.limits.maxPerStageDescriptorStorageImages = 4; - s->properties.limits.maxPerStageDescriptorUniformBuffers = 12; - s->properties.limits.maxPerStageResources = 128; - s->properties.limits.maxPushConstantsSize = 128; - s->properties.limits.maxSampleMaskWords = 1; - s->properties.limits.maxSamplerAllocationCount = 4000; - s->properties.limits.maxSamplerAnisotropy = 1; - s->properties.limits.maxSamplerLodBias = 2; - s->properties.limits.maxStorageBufferRange = 134217728; - s->properties.limits.maxTessellationControlPerPatchOutputComponents = 0; - s->properties.limits.maxTessellationControlPerVertexInputComponents = 0; - s->properties.limits.maxTessellationControlPerVertexOutputComponents = 0; - s->properties.limits.maxTessellationControlTotalOutputComponents = 0; - s->properties.limits.maxTessellationEvaluationInputComponents = 0; - s->properties.limits.maxTessellationEvaluationOutputComponents = 0; - s->properties.limits.maxTessellationGenerationLevel = 0; - s->properties.limits.maxTessellationPatchSize = 0; - s->properties.limits.maxTexelBufferElements = 65536; - s->properties.limits.maxTexelGatherOffset = 7; - s->properties.limits.maxTexelOffset = 7; - s->properties.limits.maxUniformBufferRange = 16384; - s->properties.limits.maxVertexInputAttributeOffset = 2047; - s->properties.limits.maxVertexInputAttributes = 16; - s->properties.limits.maxVertexInputBindingStride = 2048; - s->properties.limits.maxVertexInputBindings = 16; - s->properties.limits.maxVertexOutputComponents = 64; - s->properties.limits.maxViewportDimensions[0] = 4096; - s->properties.limits.maxViewportDimensions[1] = 4096; - s->properties.limits.maxViewports = 1; - s->properties.limits.minInterpolationOffset = 0.0f; - s->properties.limits.minMemoryMapAlignment = 64; - s->properties.limits.minStorageBufferOffsetAlignment = 256; - s->properties.limits.minTexelBufferOffsetAlignment = 256; - s->properties.limits.minTexelGatherOffset = -8; - s->properties.limits.minTexelOffset = -8; - s->properties.limits.minUniformBufferOffsetAlignment = 256; - s->properties.limits.mipmapPrecisionBits = 4; - s->properties.limits.nonCoherentAtomSize = 256; - s->properties.limits.pointSizeGranularity = 1.0f; - s->properties.limits.pointSizeRange[0] = 1.0f; - s->properties.limits.pointSizeRange[1] = 1.0f; - s->properties.limits.sampledImageColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sampledImageDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sampledImageIntegerSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sampledImageStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sparseAddressSpaceSize = 0; - s->properties.limits.storageImageSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); - s->properties.limits.subPixelInterpolationOffsetBits = 0; - s->properties.limits.subPixelPrecisionBits = 4; - s->properties.limits.subTexelPrecisionBits = 4; - s->properties.limits.viewportBoundsRange[0] = -8192; - s->properties.limits.viewportBoundsRange[1] = 8192; - s->properties.limits.viewportSubPixelBits = 0; - s->properties.sparseProperties.residencyNonResidentStrict = VK_FALSE; - s->properties.sparseProperties.residencyStandard2DBlockShape = VK_FALSE; - s->properties.sparseProperties.residencyStandard2DMultisampleBlockShape = VK_FALSE; - s->properties.sparseProperties.residencyStandard3DBlockShape = VK_FALSE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->properties.limits.bufferImageGranularity <= 131072); - ret = ret && ((131072 % s->properties.limits.bufferImageGranularity) == 0); - ret = ret && (s->properties.limits.discreteQueuePriorities >= 2); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (s->properties.limits.lineWidthGranularity <= 1.0); - ret = ret && (isMultiple(1.0, s->properties.limits.lineWidthGranularity)); - ret = ret && (s->properties.limits.lineWidthRange[0] <= 1.0); - ret = ret && (s->properties.limits.lineWidthRange[1] >= 1.0); - ret = ret && (s->properties.limits.maxBoundDescriptorSets >= 4); - ret = ret && (s->properties.limits.maxClipDistances >= 0); - ret = ret && (s->properties.limits.maxColorAttachments >= 4); - ret = ret && (s->properties.limits.maxCombinedClipAndCullDistances >= 0); - ret = ret && (s->properties.limits.maxComputeSharedMemorySize >= 16384); - ret = ret && (s->properties.limits.maxComputeWorkGroupCount[0] >= 65535); - ret = ret && (s->properties.limits.maxComputeWorkGroupCount[1] >= 65535); - ret = ret && (s->properties.limits.maxComputeWorkGroupCount[2] >= 65535); - ret = ret && (s->properties.limits.maxComputeWorkGroupInvocations >= 128); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[0] >= 128); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[1] >= 128); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[2] >= 64); - ret = ret && (s->properties.limits.maxCullDistances >= 0); - ret = ret && (s->properties.limits.maxDescriptorSetInputAttachments >= 4); - ret = ret && (s->properties.limits.maxDescriptorSetSampledImages >= 96); - ret = ret && (s->properties.limits.maxDescriptorSetSamplers >= 96); - ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffers >= 24); - ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4); - ret = ret && (s->properties.limits.maxDescriptorSetStorageImages >= 24); - ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffers >= 72); - ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8); - ret = ret && (s->properties.limits.maxDrawIndexedIndexValue >= 16777216); - ret = ret && (s->properties.limits.maxDrawIndirectCount >= 1); - ret = ret && (s->properties.limits.maxFragmentCombinedOutputResources >= 4); - ret = ret && (s->properties.limits.maxFragmentDualSrcAttachments >= 0); - ret = ret && (s->properties.limits.maxFragmentInputComponents >= 64); - ret = ret && (s->properties.limits.maxFragmentOutputAttachments >= 4); - ret = ret && (s->properties.limits.maxFramebufferHeight >= 4096); - ret = ret && (s->properties.limits.maxFramebufferLayers >= 256); - ret = ret && (s->properties.limits.maxFramebufferWidth >= 4096); - ret = ret && (s->properties.limits.maxGeometryInputComponents >= 0); - ret = ret && (s->properties.limits.maxGeometryOutputComponents >= 0); - ret = ret && (s->properties.limits.maxGeometryOutputVertices >= 0); - ret = ret && (s->properties.limits.maxGeometryShaderInvocations >= 0); - ret = ret && (s->properties.limits.maxGeometryTotalOutputComponents >= 0); - ret = ret && (s->properties.limits.maxImageArrayLayers >= 256); - ret = ret && (s->properties.limits.maxImageDimension1D >= 4096); - ret = ret && (s->properties.limits.maxImageDimension2D >= 4096); - ret = ret && (s->properties.limits.maxImageDimension3D >= 256); - ret = ret && (s->properties.limits.maxImageDimensionCube >= 4096); - ret = ret && (s->properties.limits.maxInterpolationOffset >= 0.0); - ret = ret && (s->properties.limits.maxMemoryAllocationCount >= 4096); - ret = ret && (s->properties.limits.maxPerStageDescriptorInputAttachments >= 4); - ret = ret && (s->properties.limits.maxPerStageDescriptorSampledImages >= 16); - ret = ret && (s->properties.limits.maxPerStageDescriptorSamplers >= 16); - ret = ret && (s->properties.limits.maxPerStageDescriptorStorageBuffers >= 4); - ret = ret && (s->properties.limits.maxPerStageDescriptorStorageImages >= 4); - ret = ret && (s->properties.limits.maxPerStageDescriptorUniformBuffers >= 12); - ret = ret && (s->properties.limits.maxPerStageResources >= 128); - ret = ret && (s->properties.limits.maxPushConstantsSize >= 128); - ret = ret && (s->properties.limits.maxSampleMaskWords >= 1); - ret = ret && (s->properties.limits.maxSamplerAllocationCount >= 4000); - ret = ret && (s->properties.limits.maxSamplerAnisotropy >= 1); - ret = ret && (s->properties.limits.maxSamplerLodBias >= 2); - ret = ret && (s->properties.limits.maxStorageBufferRange >= 134217728); - ret = ret && (s->properties.limits.maxTessellationControlPerPatchOutputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationControlPerVertexInputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationControlPerVertexOutputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationControlTotalOutputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationEvaluationInputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationEvaluationOutputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationGenerationLevel >= 0); - ret = ret && (s->properties.limits.maxTessellationPatchSize >= 0); - ret = ret && (s->properties.limits.maxTexelBufferElements >= 65536); - ret = ret && (s->properties.limits.maxTexelGatherOffset >= 7); - ret = ret && (s->properties.limits.maxTexelOffset >= 7); - ret = ret && (s->properties.limits.maxUniformBufferRange >= 16384); - ret = ret && (s->properties.limits.maxVertexInputAttributeOffset >= 2047); - ret = ret && (s->properties.limits.maxVertexInputAttributes >= 16); - ret = ret && (s->properties.limits.maxVertexInputBindingStride >= 2048); - ret = ret && (s->properties.limits.maxVertexInputBindings >= 16); - ret = ret && (s->properties.limits.maxVertexOutputComponents >= 64); - ret = ret && (s->properties.limits.maxViewportDimensions[0] >= 4096); - ret = ret && (s->properties.limits.maxViewportDimensions[1] >= 4096); - ret = ret && (s->properties.limits.maxViewports >= 1); - ret = ret && (s->properties.limits.minInterpolationOffset <= 0.0); - ret = ret && (s->properties.limits.minMemoryMapAlignment <= 64); - ret = ret && ((s->properties.limits.minMemoryMapAlignment & (s->properties.limits.minMemoryMapAlignment - 1)) == 0); - ret = ret && (s->properties.limits.minStorageBufferOffsetAlignment <= 256); - ret = ret && ((s->properties.limits.minStorageBufferOffsetAlignment & (s->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0); - ret = ret && (s->properties.limits.minTexelBufferOffsetAlignment <= 256); - ret = ret && ((s->properties.limits.minTexelBufferOffsetAlignment & (s->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0); - ret = ret && (s->properties.limits.minTexelGatherOffset <= -8); - ret = ret && (s->properties.limits.minTexelOffset <= -8); - ret = ret && (s->properties.limits.minUniformBufferOffsetAlignment <= 256); - ret = ret && ((s->properties.limits.minUniformBufferOffsetAlignment & (s->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0); - ret = ret && (s->properties.limits.mipmapPrecisionBits >= 4); - ret = ret && (s->properties.limits.nonCoherentAtomSize <= 256); - ret = ret && ((s->properties.limits.nonCoherentAtomSize & (s->properties.limits.nonCoherentAtomSize - 1)) == 0); - ret = ret && (s->properties.limits.pointSizeGranularity <= 1.0); - ret = ret && (isMultiple(1.0, s->properties.limits.pointSizeGranularity)); - ret = ret && (s->properties.limits.pointSizeRange[0] <= 1.0); - ret = ret && (s->properties.limits.pointSizeRange[1] >= 1.0); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (s->properties.limits.sparseAddressSpaceSize >= 0); - ret = ret && (vpCheckFlags(s->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); - ret = ret && (s->properties.limits.subPixelInterpolationOffsetBits >= 0); - ret = ret && (s->properties.limits.subPixelPrecisionBits >= 4); - ret = ret && (s->properties.limits.subTexelPrecisionBits >= 4); - ret = ret && (s->properties.limits.viewportBoundsRange[0] <= -8192); - ret = ret && (s->properties.limits.viewportBoundsRange[1] >= 8192); - ret = ret && (s->properties.limits.viewportSubPixelBits >= 0); - ret = ret && (vpCheckFlags(s->properties.sparseProperties.residencyNonResidentStrict, VK_FALSE)); - ret = ret && (vpCheckFlags(s->properties.sparseProperties.residencyStandard2DBlockShape, VK_FALSE)); - ret = ret && (vpCheckFlags(s->properties.sparseProperties.residencyStandard2DMultisampleBlockShape, VK_FALSE)); - ret = ret && (vpCheckFlags(s->properties.sparseProperties.residencyStandard3DBlockShape, VK_FALSE)); - } break; - default: break; - } - return ret; - } +#ifdef VP_LUNARG_desktop_baseline_2024 +namespace VP_LUNARG_DESKTOP_BASELINE_2024 +{ +static const VpVariantDesc mergedCapabilities[] = { + { + "MERGED", + 0, + nullptr, + static_cast(std::size(deviceExtensions)), + deviceExtensions, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + featureDesc, + 0, + nullptr, + propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + chainerDesc, + 0, + nullptr, + }, }; -static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Features)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); +namespace blocks +{ +namespace VP_LUNARG_desktop_baseline_2024_block +{ +static const VpVariantDesc variants[] = { + { + "VP_LUNARG_desktop_baseline_2024_block", + 0, + nullptr, + static_cast(std::size(blocks::VP_LUNARG_desktop_baseline_2024_block::deviceExtensions)), + blocks::VP_LUNARG_desktop_baseline_2024_block::deviceExtensions, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::VP_LUNARG_desktop_baseline_2024_block::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::VP_LUNARG_desktop_baseline_2024_block::propertyDesc, + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(formatStructTypes)), + formatStructTypes, + static_cast(std::size(blocks::VP_LUNARG_desktop_baseline_2024_block::formatDesc)), + blocks::VP_LUNARG_desktop_baseline_2024_block::formatDesc, + blocks::VP_LUNARG_desktop_baseline_2024_block::chainerDesc, + 0, + nullptr, }, }; -} //namespace vulkan10requirements -namespace vulkan11requirements { -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceVulkan11Features* s = static_cast(static_cast(p)); - s->multiview = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceVulkan11Features* s = static_cast(static_cast(p)); - ret = ret && (s->multiview == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace VP_LUNARG_desktop_baseline_2024_block +} // namespace blocks -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: { - VkPhysicalDeviceVulkan11Properties* s = static_cast(static_cast(p)); - s->maxMemoryAllocationSize = 1073741824; - s->maxMultiviewInstanceIndex = 134217727; - s->maxMultiviewViewCount = 6; - s->maxPerSetDescriptors = 1024; - s->subgroupSize = 1; - s->subgroupSupportedOperations |= (VK_SUBGROUP_FEATURE_BASIC_BIT); - s->subgroupSupportedStages |= (VK_SHADER_STAGE_COMPUTE_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: { - VkPhysicalDeviceVulkan11Properties* s = static_cast(static_cast(p)); - ret = ret && (s->maxMemoryAllocationSize >= 1073741824); - ret = ret && (s->maxMultiviewInstanceIndex >= 134217727); - ret = ret && (s->maxMultiviewViewCount >= 6); - ret = ret && (s->maxPerSetDescriptors >= 1024); - ret = ret && (s->subgroupSize >= 1); - ret = ret && ((s->subgroupSize & (s->subgroupSize - 1)) == 0); - ret = ret && (vpCheckFlags(s->subgroupSupportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT))); - ret = ret && (vpCheckFlags(s->subgroupSupportedStages, (VK_SHADER_STAGE_COMPUTE_BIT))); - } break; - default: break; - } - return ret; - } +static const VpCapabilitiesDesc capabilities[] = { + {blocks::VP_LUNARG_desktop_baseline_2024_block::variantCount, blocks::VP_LUNARG_desktop_baseline_2024_block::variants}, }; +static const uint32_t capabilityCount = static_cast(std::size(capabilities)); +} // namespace VP_LUNARG_DESKTOP_BASELINE_2024 +#endif // VP_LUNARG_desktop_baseline_2024 -static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Features)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); +#ifdef VP_LUNARG_minimum_requirements_1_0 +namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_0 +{ +static const VpVariantDesc mergedCapabilities[] = { + { + "MERGED", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + featureDesc, + 0, + nullptr, + propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + chainerDesc, + 0, + nullptr, }, }; -} //namespace vulkan11requirements -namespace vulkan12requirements { -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - s->hostQueryReset = VK_TRUE; - s->imagelessFramebuffer = VK_TRUE; - s->separateDepthStencilLayouts = VK_TRUE; - s->shaderSubgroupExtendedTypes = VK_TRUE; - s->subgroupBroadcastDynamicId = VK_TRUE; - s->timelineSemaphore = VK_TRUE; - s->uniformBufferStandardLayout = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - ret = ret && (s->hostQueryReset == VK_TRUE); - ret = ret && (s->imagelessFramebuffer == VK_TRUE); - ret = ret && (s->separateDepthStencilLayouts == VK_TRUE); - ret = ret && (s->shaderSubgroupExtendedTypes == VK_TRUE); - ret = ret && (s->subgroupBroadcastDynamicId == VK_TRUE); - ret = ret && (s->timelineSemaphore == VK_TRUE); - ret = ret && (s->uniformBufferStandardLayout == VK_TRUE); - } break; - default: break; - } - return ret; - } + +namespace blocks +{ +namespace vulkan10requirements +{ +static const VpVariantDesc variants[] = { + { + "vulkan10requirements", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan10requirements::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::vulkan10requirements::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan10requirements::chainerDesc, + 0, + nullptr, + }, }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan10requirements +} // namespace blocks -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: { - VkPhysicalDeviceVulkan12Properties* s = static_cast(static_cast(p)); - s->filterMinmaxImageComponentMapping = VK_FALSE; - s->filterMinmaxSingleComponentFormats = VK_FALSE; - s->framebufferIntegerColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); - s->independentResolve = VK_FALSE; - s->independentResolveNone = VK_FALSE; - s->maxDescriptorSetUpdateAfterBindInputAttachments = 0; - s->maxDescriptorSetUpdateAfterBindSampledImages = 0; - s->maxDescriptorSetUpdateAfterBindSamplers = 0; - s->maxDescriptorSetUpdateAfterBindStorageBuffers = 0; - s->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = 0; - s->maxDescriptorSetUpdateAfterBindStorageImages = 0; - s->maxDescriptorSetUpdateAfterBindUniformBuffers = 0; - s->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = 0; - s->maxPerStageDescriptorUpdateAfterBindInputAttachments = 0; - s->maxPerStageDescriptorUpdateAfterBindSampledImages = 0; - s->maxPerStageDescriptorUpdateAfterBindSamplers = 0; - s->maxPerStageDescriptorUpdateAfterBindStorageBuffers = 0; - s->maxPerStageDescriptorUpdateAfterBindStorageImages = 0; - s->maxPerStageDescriptorUpdateAfterBindUniformBuffers = 0; - s->maxPerStageUpdateAfterBindResources = 0; - s->maxTimelineSemaphoreValueDifference = 2147483647; - s->maxUpdateAfterBindDescriptorsInAllPools = 0; - s->quadDivergentImplicitLod = VK_FALSE; - s->robustBufferAccessUpdateAfterBind = VK_FALSE; - s->shaderDenormFlushToZeroFloat16 = VK_FALSE; - s->shaderDenormFlushToZeroFloat32 = VK_FALSE; - s->shaderDenormFlushToZeroFloat64 = VK_FALSE; - s->shaderDenormPreserveFloat16 = VK_FALSE; - s->shaderDenormPreserveFloat32 = VK_FALSE; - s->shaderDenormPreserveFloat64 = VK_FALSE; - s->shaderInputAttachmentArrayNonUniformIndexingNative = VK_FALSE; - s->shaderRoundingModeRTEFloat16 = VK_FALSE; - s->shaderRoundingModeRTEFloat32 = VK_FALSE; - s->shaderRoundingModeRTEFloat64 = VK_FALSE; - s->shaderRoundingModeRTZFloat16 = VK_FALSE; - s->shaderRoundingModeRTZFloat32 = VK_FALSE; - s->shaderRoundingModeRTZFloat64 = VK_FALSE; - s->shaderSampledImageArrayNonUniformIndexingNative = VK_FALSE; - s->shaderSignedZeroInfNanPreserveFloat16 = VK_FALSE; - s->shaderSignedZeroInfNanPreserveFloat32 = VK_FALSE; - s->shaderSignedZeroInfNanPreserveFloat64 = VK_FALSE; - s->shaderStorageBufferArrayNonUniformIndexingNative = VK_FALSE; - s->shaderStorageImageArrayNonUniformIndexingNative = VK_FALSE; - s->shaderUniformBufferArrayNonUniformIndexingNative = VK_FALSE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: { - VkPhysicalDeviceVulkan12Properties* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->filterMinmaxImageComponentMapping, VK_FALSE)); - ret = ret && (vpCheckFlags(s->filterMinmaxSingleComponentFormats, VK_FALSE)); - ret = ret && (vpCheckFlags(s->framebufferIntegerColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); - ret = ret && (vpCheckFlags(s->independentResolve, VK_FALSE)); - ret = ret && (vpCheckFlags(s->independentResolveNone, VK_FALSE)); - ret = ret && (s->maxDescriptorSetUpdateAfterBindInputAttachments >= 0); - ret = ret && (s->maxDescriptorSetUpdateAfterBindSampledImages >= 0); - ret = ret && (s->maxDescriptorSetUpdateAfterBindSamplers >= 0); - ret = ret && (s->maxDescriptorSetUpdateAfterBindStorageBuffers >= 0); - ret = ret && (s->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 0); - ret = ret && (s->maxDescriptorSetUpdateAfterBindStorageImages >= 0); - ret = ret && (s->maxDescriptorSetUpdateAfterBindUniformBuffers >= 0); - ret = ret && (s->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 0); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindInputAttachments >= 0); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindSampledImages >= 0); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindSamplers >= 0); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 0); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindStorageImages >= 0); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 0); - ret = ret && (s->maxPerStageUpdateAfterBindResources >= 0); - ret = ret && (s->maxTimelineSemaphoreValueDifference >= 2147483647); - ret = ret && (s->maxUpdateAfterBindDescriptorsInAllPools >= 0); - ret = ret && (vpCheckFlags(s->quadDivergentImplicitLod, VK_FALSE)); - ret = ret && (vpCheckFlags(s->robustBufferAccessUpdateAfterBind, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderDenormFlushToZeroFloat16, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderDenormFlushToZeroFloat32, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderDenormFlushToZeroFloat64, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderDenormPreserveFloat16, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderDenormPreserveFloat32, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderDenormPreserveFloat64, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderInputAttachmentArrayNonUniformIndexingNative, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderRoundingModeRTEFloat16, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderRoundingModeRTEFloat32, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderRoundingModeRTEFloat64, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderRoundingModeRTZFloat16, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderRoundingModeRTZFloat32, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderRoundingModeRTZFloat64, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderSampledImageArrayNonUniformIndexingNative, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderSignedZeroInfNanPreserveFloat16, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderSignedZeroInfNanPreserveFloat32, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderSignedZeroInfNanPreserveFloat64, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderStorageBufferArrayNonUniformIndexingNative, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderStorageImageArrayNonUniformIndexingNative, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderUniformBufferArrayNonUniformIndexingNative, VK_FALSE)); - } break; - default: break; - } - return ret; - } +static const VpCapabilitiesDesc capabilities[] = { + {blocks::vulkan10requirements::variantCount, blocks::vulkan10requirements::variants}, }; +static const uint32_t capabilityCount = static_cast(std::size(capabilities)); +} // namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_0 +#endif // VP_LUNARG_minimum_requirements_1_0 -static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Features)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan12Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); +#ifdef VP_LUNARG_minimum_requirements_1_1 +namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_1 +{ +static const VpVariantDesc mergedCapabilities[] = { + { + "MERGED", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + featureDesc, + 0, + nullptr, + propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + chainerDesc, + 0, + nullptr, }, }; -} //namespace vulkan12requirements -} // namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_2 -#endif // VP_LUNARG_minimum_requirements_1_2 - -#ifdef VP_LUNARG_minimum_requirements_1_3 -namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_3 { -static const VkStructureType featureStructTypes[] = { - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, +namespace blocks +{ +namespace vulkan10requirements +{ +static const VpVariantDesc variants[] = { + { + "vulkan10requirements", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan10requirements::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::vulkan10requirements::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan10requirements::chainerDesc, + 0, + nullptr, + }, }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan10requirements -static const VkStructureType propertyStructTypes[] = { - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, +namespace vulkan11requirements_split +{ +static const VpVariantDesc variants[] = { + { + "vulkan11requirements_split", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan11requirements_split::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::vulkan11requirements_split::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan11requirements_split::chainerDesc, + 0, + nullptr, + }, }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan11requirements_split +} // namespace blocks -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.robustBufferAccess = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceVulkan11Features* s = static_cast(static_cast(p)); - s->multiview = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - s->bufferDeviceAddress = VK_TRUE; - s->hostQueryReset = VK_TRUE; - s->imagelessFramebuffer = VK_TRUE; - s->separateDepthStencilLayouts = VK_TRUE; - s->shaderSubgroupExtendedTypes = VK_TRUE; - s->subgroupBroadcastDynamicId = VK_TRUE; - s->timelineSemaphore = VK_TRUE; - s->uniformBufferStandardLayout = VK_TRUE; - s->vulkanMemoryModel = VK_TRUE; - s->vulkanMemoryModelDeviceScope = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: { - VkPhysicalDeviceVulkan13Features* s = static_cast(static_cast(p)); - s->computeFullSubgroups = VK_TRUE; - s->dynamicRendering = VK_TRUE; - s->inlineUniformBlock = VK_TRUE; - s->maintenance4 = VK_TRUE; - s->pipelineCreationCacheControl = VK_TRUE; - s->robustImageAccess = VK_TRUE; - s->shaderDemoteToHelperInvocation = VK_TRUE; - s->shaderIntegerDotProduct = VK_TRUE; - s->shaderTerminateInvocation = VK_TRUE; - s->shaderZeroInitializeWorkgroupMemory = VK_TRUE; - s->subgroupSizeControl = VK_TRUE; - s->synchronization2 = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.robustBufferAccess == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceVulkan11Features* s = static_cast(static_cast(p)); - ret = ret && (s->multiview == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - ret = ret && (s->bufferDeviceAddress == VK_TRUE); - ret = ret && (s->hostQueryReset == VK_TRUE); - ret = ret && (s->imagelessFramebuffer == VK_TRUE); - ret = ret && (s->separateDepthStencilLayouts == VK_TRUE); - ret = ret && (s->shaderSubgroupExtendedTypes == VK_TRUE); - ret = ret && (s->subgroupBroadcastDynamicId == VK_TRUE); - ret = ret && (s->timelineSemaphore == VK_TRUE); - ret = ret && (s->uniformBufferStandardLayout == VK_TRUE); - ret = ret && (s->vulkanMemoryModel == VK_TRUE); - ret = ret && (s->vulkanMemoryModelDeviceScope == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: { - VkPhysicalDeviceVulkan13Features* s = static_cast(static_cast(p)); - ret = ret && (s->computeFullSubgroups == VK_TRUE); - ret = ret && (s->dynamicRendering == VK_TRUE); - ret = ret && (s->inlineUniformBlock == VK_TRUE); - ret = ret && (s->maintenance4 == VK_TRUE); - ret = ret && (s->pipelineCreationCacheControl == VK_TRUE); - ret = ret && (s->robustImageAccess == VK_TRUE); - ret = ret && (s->shaderDemoteToHelperInvocation == VK_TRUE); - ret = ret && (s->shaderIntegerDotProduct == VK_TRUE); - ret = ret && (s->shaderTerminateInvocation == VK_TRUE); - ret = ret && (s->shaderZeroInitializeWorkgroupMemory == VK_TRUE); - ret = ret && (s->subgroupSizeControl == VK_TRUE); - ret = ret && (s->synchronization2 == VK_TRUE); - } break; - default: break; - } - return ret; - } +static const VpCapabilitiesDesc capabilities[] = { + {blocks::vulkan10requirements::variantCount, blocks::vulkan10requirements::variants}, + {blocks::vulkan11requirements_split::variantCount, blocks::vulkan11requirements_split::variants}, }; +static const uint32_t capabilityCount = static_cast(std::size(capabilities)); +} // namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_1 +#endif // VP_LUNARG_minimum_requirements_1_1 -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; +#ifdef VP_LUNARG_minimum_requirements_1_2 +namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_2 +{ +static const VpVariantDesc mergedCapabilities[] = { + { + "MERGED", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + featureDesc, + 0, + nullptr, + propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + chainerDesc, + 0, + nullptr, }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - return ret; - } }; -static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); +namespace blocks +{ +namespace vulkan10requirements +{ +static const VpVariantDesc variants[] = { + { + "vulkan10requirements", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan10requirements::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::vulkan10requirements::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan10requirements::chainerDesc, + 0, + nullptr, }, }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan10requirements -namespace vulkan10requirements { -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - s->features.robustBufferAccess = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { - VkPhysicalDeviceFeatures2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->features.robustBufferAccess == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; - -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - s->properties.limits.bufferImageGranularity = 131072; - s->properties.limits.discreteQueuePriorities = 2; - s->properties.limits.framebufferColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.framebufferDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.framebufferNoAttachmentsSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.framebufferStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.lineWidthGranularity = 1.0f; - s->properties.limits.lineWidthRange[0] = 1.0f; - s->properties.limits.lineWidthRange[1] = 1.0f; - s->properties.limits.maxBoundDescriptorSets = 4; - s->properties.limits.maxClipDistances = 0; - s->properties.limits.maxColorAttachments = 4; - s->properties.limits.maxCombinedClipAndCullDistances = 0; - s->properties.limits.maxComputeSharedMemorySize = 16384; - s->properties.limits.maxComputeWorkGroupCount[0] = 65535; - s->properties.limits.maxComputeWorkGroupCount[1] = 65535; - s->properties.limits.maxComputeWorkGroupCount[2] = 65535; - s->properties.limits.maxComputeWorkGroupInvocations = 128; - s->properties.limits.maxComputeWorkGroupSize[0] = 128; - s->properties.limits.maxComputeWorkGroupSize[1] = 128; - s->properties.limits.maxComputeWorkGroupSize[2] = 64; - s->properties.limits.maxCullDistances = 0; - s->properties.limits.maxDescriptorSetInputAttachments = 4; - s->properties.limits.maxDescriptorSetSampledImages = 96; - s->properties.limits.maxDescriptorSetSamplers = 96; - s->properties.limits.maxDescriptorSetStorageBuffers = 24; - s->properties.limits.maxDescriptorSetStorageBuffersDynamic = 4; - s->properties.limits.maxDescriptorSetStorageImages = 24; - s->properties.limits.maxDescriptorSetUniformBuffers = 72; - s->properties.limits.maxDescriptorSetUniformBuffersDynamic = 8; - s->properties.limits.maxDrawIndexedIndexValue = 16777216; - s->properties.limits.maxDrawIndirectCount = 1; - s->properties.limits.maxFragmentCombinedOutputResources = 4; - s->properties.limits.maxFragmentDualSrcAttachments = 0; - s->properties.limits.maxFragmentInputComponents = 64; - s->properties.limits.maxFragmentOutputAttachments = 4; - s->properties.limits.maxFramebufferHeight = 4096; - s->properties.limits.maxFramebufferLayers = 256; - s->properties.limits.maxFramebufferWidth = 4096; - s->properties.limits.maxGeometryInputComponents = 0; - s->properties.limits.maxGeometryOutputComponents = 0; - s->properties.limits.maxGeometryOutputVertices = 0; - s->properties.limits.maxGeometryShaderInvocations = 0; - s->properties.limits.maxGeometryTotalOutputComponents = 0; - s->properties.limits.maxImageArrayLayers = 256; - s->properties.limits.maxImageDimension1D = 4096; - s->properties.limits.maxImageDimension2D = 4096; - s->properties.limits.maxImageDimension3D = 256; - s->properties.limits.maxImageDimensionCube = 4096; - s->properties.limits.maxInterpolationOffset = 0.0f; - s->properties.limits.maxMemoryAllocationCount = 4096; - s->properties.limits.maxPerStageDescriptorInputAttachments = 4; - s->properties.limits.maxPerStageDescriptorSampledImages = 16; - s->properties.limits.maxPerStageDescriptorSamplers = 16; - s->properties.limits.maxPerStageDescriptorStorageBuffers = 4; - s->properties.limits.maxPerStageDescriptorStorageImages = 4; - s->properties.limits.maxPerStageDescriptorUniformBuffers = 12; - s->properties.limits.maxPerStageResources = 128; - s->properties.limits.maxPushConstantsSize = 128; - s->properties.limits.maxSampleMaskWords = 1; - s->properties.limits.maxSamplerAllocationCount = 4000; - s->properties.limits.maxSamplerAnisotropy = 1; - s->properties.limits.maxSamplerLodBias = 2; - s->properties.limits.maxStorageBufferRange = 134217728; - s->properties.limits.maxTessellationControlPerPatchOutputComponents = 0; - s->properties.limits.maxTessellationControlPerVertexInputComponents = 0; - s->properties.limits.maxTessellationControlPerVertexOutputComponents = 0; - s->properties.limits.maxTessellationControlTotalOutputComponents = 0; - s->properties.limits.maxTessellationEvaluationInputComponents = 0; - s->properties.limits.maxTessellationEvaluationOutputComponents = 0; - s->properties.limits.maxTessellationGenerationLevel = 0; - s->properties.limits.maxTessellationPatchSize = 0; - s->properties.limits.maxTexelBufferElements = 65536; - s->properties.limits.maxTexelGatherOffset = 7; - s->properties.limits.maxTexelOffset = 7; - s->properties.limits.maxUniformBufferRange = 16384; - s->properties.limits.maxVertexInputAttributeOffset = 2047; - s->properties.limits.maxVertexInputAttributes = 16; - s->properties.limits.maxVertexInputBindingStride = 2048; - s->properties.limits.maxVertexInputBindings = 16; - s->properties.limits.maxVertexOutputComponents = 64; - s->properties.limits.maxViewportDimensions[0] = 4096; - s->properties.limits.maxViewportDimensions[1] = 4096; - s->properties.limits.maxViewports = 1; - s->properties.limits.minInterpolationOffset = 0.0f; - s->properties.limits.minMemoryMapAlignment = 64; - s->properties.limits.minStorageBufferOffsetAlignment = 256; - s->properties.limits.minTexelBufferOffsetAlignment = 256; - s->properties.limits.minTexelGatherOffset = -8; - s->properties.limits.minTexelOffset = -8; - s->properties.limits.minUniformBufferOffsetAlignment = 256; - s->properties.limits.mipmapPrecisionBits = 4; - s->properties.limits.nonCoherentAtomSize = 256; - s->properties.limits.pointSizeGranularity = 1.0f; - s->properties.limits.pointSizeRange[0] = 1.0f; - s->properties.limits.pointSizeRange[1] = 1.0f; - s->properties.limits.sampledImageColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sampledImageDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sampledImageIntegerSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sampledImageStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); - s->properties.limits.sparseAddressSpaceSize = 0; - s->properties.limits.storageImageSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); - s->properties.limits.subPixelInterpolationOffsetBits = 0; - s->properties.limits.subPixelPrecisionBits = 4; - s->properties.limits.subTexelPrecisionBits = 4; - s->properties.limits.viewportBoundsRange[0] = -8192; - s->properties.limits.viewportBoundsRange[1] = 8192; - s->properties.limits.viewportSubPixelBits = 0; - s->properties.sparseProperties.residencyNonResidentStrict = VK_FALSE; - s->properties.sparseProperties.residencyStandard2DBlockShape = VK_FALSE; - s->properties.sparseProperties.residencyStandard2DMultisampleBlockShape = VK_FALSE; - s->properties.sparseProperties.residencyStandard3DBlockShape = VK_FALSE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: { - VkPhysicalDeviceProperties2KHR* s = static_cast(static_cast(p)); - ret = ret && (s->properties.limits.bufferImageGranularity <= 131072); - ret = ret && ((131072 % s->properties.limits.bufferImageGranularity) == 0); - ret = ret && (s->properties.limits.discreteQueuePriorities >= 2); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (s->properties.limits.lineWidthGranularity <= 1.0); - ret = ret && (isMultiple(1.0, s->properties.limits.lineWidthGranularity)); - ret = ret && (s->properties.limits.lineWidthRange[0] <= 1.0); - ret = ret && (s->properties.limits.lineWidthRange[1] >= 1.0); - ret = ret && (s->properties.limits.maxBoundDescriptorSets >= 4); - ret = ret && (s->properties.limits.maxClipDistances >= 0); - ret = ret && (s->properties.limits.maxColorAttachments >= 4); - ret = ret && (s->properties.limits.maxCombinedClipAndCullDistances >= 0); - ret = ret && (s->properties.limits.maxComputeSharedMemorySize >= 16384); - ret = ret && (s->properties.limits.maxComputeWorkGroupCount[0] >= 65535); - ret = ret && (s->properties.limits.maxComputeWorkGroupCount[1] >= 65535); - ret = ret && (s->properties.limits.maxComputeWorkGroupCount[2] >= 65535); - ret = ret && (s->properties.limits.maxComputeWorkGroupInvocations >= 128); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[0] >= 128); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[1] >= 128); - ret = ret && (s->properties.limits.maxComputeWorkGroupSize[2] >= 64); - ret = ret && (s->properties.limits.maxCullDistances >= 0); - ret = ret && (s->properties.limits.maxDescriptorSetInputAttachments >= 4); - ret = ret && (s->properties.limits.maxDescriptorSetSampledImages >= 96); - ret = ret && (s->properties.limits.maxDescriptorSetSamplers >= 96); - ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffers >= 24); - ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4); - ret = ret && (s->properties.limits.maxDescriptorSetStorageImages >= 24); - ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffers >= 72); - ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8); - ret = ret && (s->properties.limits.maxDrawIndexedIndexValue >= 16777216); - ret = ret && (s->properties.limits.maxDrawIndirectCount >= 1); - ret = ret && (s->properties.limits.maxFragmentCombinedOutputResources >= 4); - ret = ret && (s->properties.limits.maxFragmentDualSrcAttachments >= 0); - ret = ret && (s->properties.limits.maxFragmentInputComponents >= 64); - ret = ret && (s->properties.limits.maxFragmentOutputAttachments >= 4); - ret = ret && (s->properties.limits.maxFramebufferHeight >= 4096); - ret = ret && (s->properties.limits.maxFramebufferLayers >= 256); - ret = ret && (s->properties.limits.maxFramebufferWidth >= 4096); - ret = ret && (s->properties.limits.maxGeometryInputComponents >= 0); - ret = ret && (s->properties.limits.maxGeometryOutputComponents >= 0); - ret = ret && (s->properties.limits.maxGeometryOutputVertices >= 0); - ret = ret && (s->properties.limits.maxGeometryShaderInvocations >= 0); - ret = ret && (s->properties.limits.maxGeometryTotalOutputComponents >= 0); - ret = ret && (s->properties.limits.maxImageArrayLayers >= 256); - ret = ret && (s->properties.limits.maxImageDimension1D >= 4096); - ret = ret && (s->properties.limits.maxImageDimension2D >= 4096); - ret = ret && (s->properties.limits.maxImageDimension3D >= 256); - ret = ret && (s->properties.limits.maxImageDimensionCube >= 4096); - ret = ret && (s->properties.limits.maxInterpolationOffset >= 0.0); - ret = ret && (s->properties.limits.maxMemoryAllocationCount >= 4096); - ret = ret && (s->properties.limits.maxPerStageDescriptorInputAttachments >= 4); - ret = ret && (s->properties.limits.maxPerStageDescriptorSampledImages >= 16); - ret = ret && (s->properties.limits.maxPerStageDescriptorSamplers >= 16); - ret = ret && (s->properties.limits.maxPerStageDescriptorStorageBuffers >= 4); - ret = ret && (s->properties.limits.maxPerStageDescriptorStorageImages >= 4); - ret = ret && (s->properties.limits.maxPerStageDescriptorUniformBuffers >= 12); - ret = ret && (s->properties.limits.maxPerStageResources >= 128); - ret = ret && (s->properties.limits.maxPushConstantsSize >= 128); - ret = ret && (s->properties.limits.maxSampleMaskWords >= 1); - ret = ret && (s->properties.limits.maxSamplerAllocationCount >= 4000); - ret = ret && (s->properties.limits.maxSamplerAnisotropy >= 1); - ret = ret && (s->properties.limits.maxSamplerLodBias >= 2); - ret = ret && (s->properties.limits.maxStorageBufferRange >= 134217728); - ret = ret && (s->properties.limits.maxTessellationControlPerPatchOutputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationControlPerVertexInputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationControlPerVertexOutputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationControlTotalOutputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationEvaluationInputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationEvaluationOutputComponents >= 0); - ret = ret && (s->properties.limits.maxTessellationGenerationLevel >= 0); - ret = ret && (s->properties.limits.maxTessellationPatchSize >= 0); - ret = ret && (s->properties.limits.maxTexelBufferElements >= 65536); - ret = ret && (s->properties.limits.maxTexelGatherOffset >= 7); - ret = ret && (s->properties.limits.maxTexelOffset >= 7); - ret = ret && (s->properties.limits.maxUniformBufferRange >= 16384); - ret = ret && (s->properties.limits.maxVertexInputAttributeOffset >= 2047); - ret = ret && (s->properties.limits.maxVertexInputAttributes >= 16); - ret = ret && (s->properties.limits.maxVertexInputBindingStride >= 2048); - ret = ret && (s->properties.limits.maxVertexInputBindings >= 16); - ret = ret && (s->properties.limits.maxVertexOutputComponents >= 64); - ret = ret && (s->properties.limits.maxViewportDimensions[0] >= 4096); - ret = ret && (s->properties.limits.maxViewportDimensions[1] >= 4096); - ret = ret && (s->properties.limits.maxViewports >= 1); - ret = ret && (s->properties.limits.minInterpolationOffset <= 0.0); - ret = ret && (s->properties.limits.minMemoryMapAlignment <= 64); - ret = ret && ((s->properties.limits.minMemoryMapAlignment & (s->properties.limits.minMemoryMapAlignment - 1)) == 0); - ret = ret && (s->properties.limits.minStorageBufferOffsetAlignment <= 256); - ret = ret && ((s->properties.limits.minStorageBufferOffsetAlignment & (s->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0); - ret = ret && (s->properties.limits.minTexelBufferOffsetAlignment <= 256); - ret = ret && ((s->properties.limits.minTexelBufferOffsetAlignment & (s->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0); - ret = ret && (s->properties.limits.minTexelGatherOffset <= -8); - ret = ret && (s->properties.limits.minTexelOffset <= -8); - ret = ret && (s->properties.limits.minUniformBufferOffsetAlignment <= 256); - ret = ret && ((s->properties.limits.minUniformBufferOffsetAlignment & (s->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0); - ret = ret && (s->properties.limits.mipmapPrecisionBits >= 4); - ret = ret && (s->properties.limits.nonCoherentAtomSize <= 256); - ret = ret && ((s->properties.limits.nonCoherentAtomSize & (s->properties.limits.nonCoherentAtomSize - 1)) == 0); - ret = ret && (s->properties.limits.pointSizeGranularity <= 1.0); - ret = ret && (isMultiple(1.0, s->properties.limits.pointSizeGranularity)); - ret = ret && (s->properties.limits.pointSizeRange[0] <= 1.0); - ret = ret && (s->properties.limits.pointSizeRange[1] >= 1.0); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (vpCheckFlags(s->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT))); - ret = ret && (s->properties.limits.sparseAddressSpaceSize >= 0); - ret = ret && (vpCheckFlags(s->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); - ret = ret && (s->properties.limits.subPixelInterpolationOffsetBits >= 0); - ret = ret && (s->properties.limits.subPixelPrecisionBits >= 4); - ret = ret && (s->properties.limits.subTexelPrecisionBits >= 4); - ret = ret && (s->properties.limits.viewportBoundsRange[0] <= -8192); - ret = ret && (s->properties.limits.viewportBoundsRange[1] >= 8192); - ret = ret && (s->properties.limits.viewportSubPixelBits >= 0); - ret = ret && (vpCheckFlags(s->properties.sparseProperties.residencyNonResidentStrict, VK_FALSE)); - ret = ret && (vpCheckFlags(s->properties.sparseProperties.residencyStandard2DBlockShape, VK_FALSE)); - ret = ret && (vpCheckFlags(s->properties.sparseProperties.residencyStandard2DMultisampleBlockShape, VK_FALSE)); - ret = ret && (vpCheckFlags(s->properties.sparseProperties.residencyStandard3DBlockShape, VK_FALSE)); - } break; - default: break; - } - return ret; - } +namespace vulkan11requirements +{ +static const VpVariantDesc variants[] = { + { + "vulkan11requirements", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan11requirements::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::vulkan11requirements::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan11requirements::chainerDesc, + 0, + nullptr, + }, }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan11requirements -static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); +namespace vulkan12requirements +{ +static const VpVariantDesc variants[] = { + { + "vulkan12requirements", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan12requirements::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::vulkan12requirements::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan12requirements::chainerDesc, + 0, + nullptr, }, }; -} //namespace vulkan10requirements -namespace vulkan11requirements { -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceVulkan11Features* s = static_cast(static_cast(p)); - s->multiview = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceVulkan11Features* s = static_cast(static_cast(p)); - ret = ret && (s->multiview == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; - -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: { - VkPhysicalDeviceVulkan11Properties* s = static_cast(static_cast(p)); - s->maxMemoryAllocationSize = 1073741824; - s->maxMultiviewInstanceIndex = 134217727; - s->maxMultiviewViewCount = 6; - s->maxPerSetDescriptors = 1024; - s->subgroupSize = 1; - s->subgroupSupportedOperations |= (VK_SUBGROUP_FEATURE_BASIC_BIT); - s->subgroupSupportedStages |= (VK_SHADER_STAGE_COMPUTE_BIT); - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: { - VkPhysicalDeviceVulkan11Properties* s = static_cast(static_cast(p)); - ret = ret && (s->maxMemoryAllocationSize >= 1073741824); - ret = ret && (s->maxMultiviewInstanceIndex >= 134217727); - ret = ret && (s->maxMultiviewViewCount >= 6); - ret = ret && (s->maxPerSetDescriptors >= 1024); - ret = ret && (s->subgroupSize >= 1); - ret = ret && ((s->subgroupSize & (s->subgroupSize - 1)) == 0); - ret = ret && (vpCheckFlags(s->subgroupSupportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT))); - ret = ret && (vpCheckFlags(s->subgroupSupportedStages, (VK_SHADER_STAGE_COMPUTE_BIT))); - } break; - default: break; - } - return ret; - } +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan12requirements +} // namespace blocks + +static const VpCapabilitiesDesc capabilities[] = { + {blocks::vulkan10requirements::variantCount, blocks::vulkan10requirements::variants}, + {blocks::vulkan11requirements::variantCount, blocks::vulkan11requirements::variants}, + {blocks::vulkan12requirements::variantCount, blocks::vulkan12requirements::variants}, }; +static const uint32_t capabilityCount = static_cast(std::size(capabilities)); +} // namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_2 +#endif // VP_LUNARG_minimum_requirements_1_2 -static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); +#ifdef VP_LUNARG_minimum_requirements_1_3 +namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_3 +{ +static const VpVariantDesc mergedCapabilities[] = { + { + "MERGED", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + featureDesc, + 0, + nullptr, + propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + chainerDesc, + 0, + nullptr, }, }; -} //namespace vulkan11requirements -namespace vulkan12requirements { -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - s->hostQueryReset = VK_TRUE; - s->imagelessFramebuffer = VK_TRUE; - s->separateDepthStencilLayouts = VK_TRUE; - s->shaderSubgroupExtendedTypes = VK_TRUE; - s->subgroupBroadcastDynamicId = VK_TRUE; - s->timelineSemaphore = VK_TRUE; - s->uniformBufferStandardLayout = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - ret = ret && (s->hostQueryReset == VK_TRUE); - ret = ret && (s->imagelessFramebuffer == VK_TRUE); - ret = ret && (s->separateDepthStencilLayouts == VK_TRUE); - ret = ret && (s->shaderSubgroupExtendedTypes == VK_TRUE); - ret = ret && (s->subgroupBroadcastDynamicId == VK_TRUE); - ret = ret && (s->timelineSemaphore == VK_TRUE); - ret = ret && (s->uniformBufferStandardLayout == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: { - VkPhysicalDeviceVulkan12Properties* s = static_cast(static_cast(p)); - s->filterMinmaxImageComponentMapping = VK_FALSE; - s->filterMinmaxSingleComponentFormats = VK_FALSE; - s->framebufferIntegerColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT); - s->independentResolve = VK_FALSE; - s->independentResolveNone = VK_FALSE; - s->maxDescriptorSetUpdateAfterBindInputAttachments = 0; - s->maxDescriptorSetUpdateAfterBindSampledImages = 0; - s->maxDescriptorSetUpdateAfterBindSamplers = 0; - s->maxDescriptorSetUpdateAfterBindStorageBuffers = 0; - s->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = 0; - s->maxDescriptorSetUpdateAfterBindStorageImages = 0; - s->maxDescriptorSetUpdateAfterBindUniformBuffers = 0; - s->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = 0; - s->maxPerStageDescriptorUpdateAfterBindInputAttachments = 0; - s->maxPerStageDescriptorUpdateAfterBindSampledImages = 0; - s->maxPerStageDescriptorUpdateAfterBindSamplers = 0; - s->maxPerStageDescriptorUpdateAfterBindStorageBuffers = 0; - s->maxPerStageDescriptorUpdateAfterBindStorageImages = 0; - s->maxPerStageDescriptorUpdateAfterBindUniformBuffers = 0; - s->maxPerStageUpdateAfterBindResources = 0; - s->maxTimelineSemaphoreValueDifference = 2147483647; - s->maxUpdateAfterBindDescriptorsInAllPools = 0; - s->quadDivergentImplicitLod = VK_FALSE; - s->robustBufferAccessUpdateAfterBind = VK_FALSE; - s->shaderDenormFlushToZeroFloat16 = VK_FALSE; - s->shaderDenormFlushToZeroFloat32 = VK_FALSE; - s->shaderDenormFlushToZeroFloat64 = VK_FALSE; - s->shaderDenormPreserveFloat16 = VK_FALSE; - s->shaderDenormPreserveFloat32 = VK_FALSE; - s->shaderDenormPreserveFloat64 = VK_FALSE; - s->shaderInputAttachmentArrayNonUniformIndexingNative = VK_FALSE; - s->shaderRoundingModeRTEFloat16 = VK_FALSE; - s->shaderRoundingModeRTEFloat32 = VK_FALSE; - s->shaderRoundingModeRTEFloat64 = VK_FALSE; - s->shaderRoundingModeRTZFloat16 = VK_FALSE; - s->shaderRoundingModeRTZFloat32 = VK_FALSE; - s->shaderRoundingModeRTZFloat64 = VK_FALSE; - s->shaderSampledImageArrayNonUniformIndexingNative = VK_FALSE; - s->shaderSignedZeroInfNanPreserveFloat16 = VK_FALSE; - s->shaderSignedZeroInfNanPreserveFloat32 = VK_FALSE; - s->shaderSignedZeroInfNanPreserveFloat64 = VK_FALSE; - s->shaderStorageBufferArrayNonUniformIndexingNative = VK_FALSE; - s->shaderStorageImageArrayNonUniformIndexingNative = VK_FALSE; - s->shaderUniformBufferArrayNonUniformIndexingNative = VK_FALSE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: { - VkPhysicalDeviceVulkan12Properties* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->filterMinmaxImageComponentMapping, VK_FALSE)); - ret = ret && (vpCheckFlags(s->filterMinmaxSingleComponentFormats, VK_FALSE)); - ret = ret && (vpCheckFlags(s->framebufferIntegerColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT))); - ret = ret && (vpCheckFlags(s->independentResolve, VK_FALSE)); - ret = ret && (vpCheckFlags(s->independentResolveNone, VK_FALSE)); - ret = ret && (s->maxDescriptorSetUpdateAfterBindInputAttachments >= 0); - ret = ret && (s->maxDescriptorSetUpdateAfterBindSampledImages >= 0); - ret = ret && (s->maxDescriptorSetUpdateAfterBindSamplers >= 0); - ret = ret && (s->maxDescriptorSetUpdateAfterBindStorageBuffers >= 0); - ret = ret && (s->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic >= 0); - ret = ret && (s->maxDescriptorSetUpdateAfterBindStorageImages >= 0); - ret = ret && (s->maxDescriptorSetUpdateAfterBindUniformBuffers >= 0); - ret = ret && (s->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic >= 0); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindInputAttachments >= 0); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindSampledImages >= 0); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindSamplers >= 0); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindStorageBuffers >= 0); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindStorageImages >= 0); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindUniformBuffers >= 0); - ret = ret && (s->maxPerStageUpdateAfterBindResources >= 0); - ret = ret && (s->maxTimelineSemaphoreValueDifference >= 2147483647); - ret = ret && (s->maxUpdateAfterBindDescriptorsInAllPools >= 0); - ret = ret && (vpCheckFlags(s->quadDivergentImplicitLod, VK_FALSE)); - ret = ret && (vpCheckFlags(s->robustBufferAccessUpdateAfterBind, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderDenormFlushToZeroFloat16, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderDenormFlushToZeroFloat32, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderDenormFlushToZeroFloat64, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderDenormPreserveFloat16, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderDenormPreserveFloat32, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderDenormPreserveFloat64, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderInputAttachmentArrayNonUniformIndexingNative, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderRoundingModeRTEFloat16, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderRoundingModeRTEFloat32, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderRoundingModeRTEFloat64, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderRoundingModeRTZFloat16, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderRoundingModeRTZFloat32, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderRoundingModeRTZFloat64, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderSampledImageArrayNonUniformIndexingNative, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderSignedZeroInfNanPreserveFloat16, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderSignedZeroInfNanPreserveFloat32, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderSignedZeroInfNanPreserveFloat64, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderStorageBufferArrayNonUniformIndexingNative, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderStorageImageArrayNonUniformIndexingNative, VK_FALSE)); - ret = ret && (vpCheckFlags(s->shaderUniformBufferArrayNonUniformIndexingNative, VK_FALSE)); - } break; - default: break; - } - return ret; - } +namespace blocks +{ +namespace vulkan10requirements +{ +static const VpVariantDesc variants[] = { + { + "vulkan10requirements", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan10requirements::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::vulkan10requirements::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan10requirements::chainerDesc, + 0, + nullptr, + }, }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan10requirements -static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); +namespace vulkan11requirements +{ +static const VpVariantDesc variants[] = { + { + "vulkan11requirements", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan11requirements::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::vulkan11requirements::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan11requirements::chainerDesc, + 0, + nullptr, }, }; -} //namespace vulkan12requirements -namespace vulkan13requirements { -static const VpFeatureDesc featureDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - s->bufferDeviceAddress = VK_TRUE; - s->vulkanMemoryModel = VK_TRUE; - s->vulkanMemoryModelDeviceScope = VK_TRUE; - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: { - VkPhysicalDeviceVulkan13Features* s = static_cast(static_cast(p)); - s->computeFullSubgroups = VK_TRUE; - s->dynamicRendering = VK_TRUE; - s->inlineUniformBlock = VK_TRUE; - s->maintenance4 = VK_TRUE; - s->pipelineCreationCacheControl = VK_TRUE; - s->robustImageAccess = VK_TRUE; - s->shaderDemoteToHelperInvocation = VK_TRUE; - s->shaderIntegerDotProduct = VK_TRUE; - s->shaderTerminateInvocation = VK_TRUE; - s->shaderZeroInitializeWorkgroupMemory = VK_TRUE; - s->subgroupSizeControl = VK_TRUE; - s->synchronization2 = VK_TRUE; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceVulkan12Features* s = static_cast(static_cast(p)); - ret = ret && (s->bufferDeviceAddress == VK_TRUE); - ret = ret && (s->vulkanMemoryModel == VK_TRUE); - ret = ret && (s->vulkanMemoryModelDeviceScope == VK_TRUE); - } break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: { - VkPhysicalDeviceVulkan13Features* s = static_cast(static_cast(p)); - ret = ret && (s->computeFullSubgroups == VK_TRUE); - ret = ret && (s->dynamicRendering == VK_TRUE); - ret = ret && (s->inlineUniformBlock == VK_TRUE); - ret = ret && (s->maintenance4 == VK_TRUE); - ret = ret && (s->pipelineCreationCacheControl == VK_TRUE); - ret = ret && (s->robustImageAccess == VK_TRUE); - ret = ret && (s->shaderDemoteToHelperInvocation == VK_TRUE); - ret = ret && (s->shaderIntegerDotProduct == VK_TRUE); - ret = ret && (s->shaderTerminateInvocation == VK_TRUE); - ret = ret && (s->shaderZeroInitializeWorkgroupMemory == VK_TRUE); - ret = ret && (s->subgroupSizeControl == VK_TRUE); - ret = ret && (s->synchronization2 == VK_TRUE); - } break; - default: break; - } - return ret; - } -}; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan11requirements -static const VpPropertyDesc propertyDesc = { - [](VkBaseOutStructure* p) { (void)p; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: { - VkPhysicalDeviceVulkan13Properties* s = static_cast(static_cast(p)); - s->integerDotProduct16BitMixedSignednessAccelerated = VK_FALSE; - s->integerDotProduct16BitSignedAccelerated = VK_FALSE; - s->integerDotProduct16BitUnsignedAccelerated = VK_FALSE; - s->integerDotProduct32BitMixedSignednessAccelerated = VK_FALSE; - s->integerDotProduct32BitSignedAccelerated = VK_FALSE; - s->integerDotProduct32BitUnsignedAccelerated = VK_FALSE; - s->integerDotProduct4x8BitPackedMixedSignednessAccelerated = VK_FALSE; - s->integerDotProduct4x8BitPackedSignedAccelerated = VK_FALSE; - s->integerDotProduct4x8BitPackedUnsignedAccelerated = VK_FALSE; - s->integerDotProduct64BitMixedSignednessAccelerated = VK_FALSE; - s->integerDotProduct64BitSignedAccelerated = VK_FALSE; - s->integerDotProduct64BitUnsignedAccelerated = VK_FALSE; - s->integerDotProduct8BitMixedSignednessAccelerated = VK_FALSE; - s->integerDotProduct8BitSignedAccelerated = VK_FALSE; - s->integerDotProduct8BitUnsignedAccelerated = VK_FALSE; - s->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = VK_FALSE; - s->integerDotProductAccumulatingSaturating16BitSignedAccelerated = VK_FALSE; - s->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = VK_FALSE; - s->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = VK_FALSE; - s->integerDotProductAccumulatingSaturating32BitSignedAccelerated = VK_FALSE; - s->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = VK_FALSE; - s->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = VK_FALSE; - s->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = VK_FALSE; - s->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = VK_FALSE; - s->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = VK_FALSE; - s->integerDotProductAccumulatingSaturating64BitSignedAccelerated = VK_FALSE; - s->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = VK_FALSE; - s->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = VK_FALSE; - s->integerDotProductAccumulatingSaturating8BitSignedAccelerated = VK_FALSE; - s->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = VK_FALSE; - s->maxBufferSize = 1073741824; - s->maxComputeWorkgroupSubgroups = 0; - s->maxDescriptorSetInlineUniformBlocks = 4; - s->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = 4; - s->maxInlineUniformBlockSize = 256; - s->maxInlineUniformTotalSize = 256; - s->maxPerStageDescriptorInlineUniformBlocks = 4; - s->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = 4; - } break; - default: break; - } - }, - [](VkBaseOutStructure* p) -> bool { (void)p; - bool ret = true; - switch (p->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: { - VkPhysicalDeviceVulkan13Properties* s = static_cast(static_cast(p)); - ret = ret && (vpCheckFlags(s->integerDotProduct16BitMixedSignednessAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProduct16BitSignedAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProduct16BitUnsignedAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProduct32BitMixedSignednessAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProduct32BitSignedAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProduct32BitUnsignedAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProduct4x8BitPackedMixedSignednessAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProduct4x8BitPackedSignedAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProduct4x8BitPackedUnsignedAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProduct64BitMixedSignednessAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProduct64BitSignedAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProduct64BitUnsignedAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProduct8BitMixedSignednessAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProduct8BitSignedAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProduct8BitUnsignedAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProductAccumulatingSaturating16BitSignedAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProductAccumulatingSaturating32BitSignedAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProductAccumulatingSaturating64BitSignedAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProductAccumulatingSaturating8BitSignedAccelerated, VK_FALSE)); - ret = ret && (vpCheckFlags(s->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, VK_FALSE)); - ret = ret && (s->maxBufferSize >= 1073741824); - ret = ret && (s->maxComputeWorkgroupSubgroups >= 0); - ret = ret && (s->maxDescriptorSetInlineUniformBlocks >= 4); - ret = ret && (s->maxDescriptorSetUpdateAfterBindInlineUniformBlocks >= 4); - ret = ret && (s->maxInlineUniformBlockSize >= 256); - ret = ret && (s->maxInlineUniformTotalSize >= 256); - ret = ret && (s->maxPerStageDescriptorInlineUniformBlocks >= 4); - ret = ret && (s->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks >= 4); - } break; - default: break; - } - return ret; - } +namespace vulkan12requirements +{ +static const VpVariantDesc variants[] = { + { + "vulkan12requirements", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan12requirements::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::vulkan12requirements::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan12requirements::chainerDesc, + 0, + nullptr, + }, }; +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan12requirements -static const VpStructChainerDesc chainerDesc = { - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, &physicalDeviceVulkan11Features }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, &physicalDeviceVulkan12Features }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Features)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr }; - VkPhysicalDeviceVulkan12Properties physicalDeviceVulkan12Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, &physicalDeviceVulkan11Properties }; - VkPhysicalDeviceVulkan13Properties physicalDeviceVulkan13Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, &physicalDeviceVulkan12Properties }; - p->pNext = static_cast(static_cast(&physicalDeviceVulkan13Properties)); - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); - }, - [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) { - pfnCb(p, pUser); +namespace vulkan13requirements +{ +static const VpVariantDesc variants[] = { + { + "vulkan13requirements", + 0, + nullptr, + 0, + nullptr, + static_cast(std::size(featureStructTypes)), + featureStructTypes, + blocks::vulkan13requirements::featureDesc, + static_cast(std::size(propertyStructTypes)), + propertyStructTypes, + blocks::vulkan13requirements::propertyDesc, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + 0, + nullptr, + blocks::vulkan13requirements::chainerDesc, + 0, + nullptr, }, }; -} //namespace vulkan13requirements -} // namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_3 -#endif // VP_LUNARG_minimum_requirements_1_3 - - -#ifdef VP_ANDROID_15_minimums -namespace VP_ANDROID_15_MINIMUMS { - namespace MUST { - static const VpVariantDesc variants[] = { - { - "MUST", - static_cast(std::size(MUST::instanceExtensions)), MUST::instanceExtensions, - static_cast(std::size(MUST::deviceExtensions)), MUST::deviceExtensions, - static_cast(std::size(featureStructTypes)), featureStructTypes, - MUST::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - MUST::propertyDesc, - 0, nullptr, - 0, nullptr, - static_cast(std::size(formatStructTypes)), formatStructTypes, - static_cast(std::size(MUST::formatDesc)), MUST::formatDesc, - MUST::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace MUST - - namespace primitivesGeneratedQuery_pipelineStatisticsQuery_ { - static const VpVariantDesc variants[] = { - { - "primitivesGeneratedQuery", - 0, nullptr, - static_cast(std::size(primitivesGeneratedQuery::deviceExtensions)), primitivesGeneratedQuery::deviceExtensions, - static_cast(std::size(featureStructTypes)), featureStructTypes, - primitivesGeneratedQuery::featureDesc, - 0, nullptr, - primitivesGeneratedQuery::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - primitivesGeneratedQuery::chainerDesc, - }, - { - "pipelineStatisticsQuery", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - pipelineStatisticsQuery::featureDesc, - 0, nullptr, - pipelineStatisticsQuery::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - pipelineStatisticsQuery::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace primitivesGeneratedQuery_pipelineStatisticsQuery_ - - namespace swBresenhamLines_hwBresenhamLines_ { - static const VpVariantDesc variants[] = { - { - "swBresenhamLines", - 0, nullptr, - static_cast(std::size(swBresenhamLines::deviceExtensions)), swBresenhamLines::deviceExtensions, - static_cast(std::size(featureStructTypes)), featureStructTypes, - swBresenhamLines::featureDesc, - 0, nullptr, - swBresenhamLines::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - swBresenhamLines::chainerDesc, - }, - { - "hwBresenhamLines", - 0, nullptr, - static_cast(std::size(hwBresenhamLines::deviceExtensions)), hwBresenhamLines::deviceExtensions, - static_cast(std::size(featureStructTypes)), featureStructTypes, - hwBresenhamLines::featureDesc, - 0, nullptr, - hwBresenhamLines::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - hwBresenhamLines::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace swBresenhamLines_hwBresenhamLines_ - - static const VpCapabilitiesDesc capabilities[] = { - { MUST::variantCount, MUST::variants }, - { primitivesGeneratedQuery_pipelineStatisticsQuery_::variantCount, primitivesGeneratedQuery_pipelineStatisticsQuery_::variants }, - { swBresenhamLines_hwBresenhamLines_::variantCount, swBresenhamLines_hwBresenhamLines_::variants }, - }; - static const uint32_t capabilityCount = static_cast(std::size(capabilities)); - - static const VpProfileProperties profiles[] = { - {VP_ANDROID_BASELINE_2022_NAME, VP_ANDROID_BASELINE_2022_SPEC_VERSION}, - }; - static const uint32_t profileCount = static_cast(std::size(profiles)); -} // namespace VP_ANDROID_15_MINIMUMS -#endif //VP_ANDROID_15_minimums - -#ifdef VP_ANDROID_16_minimums -namespace VP_ANDROID_16_MINIMUMS { - namespace MUST { - static const VpVariantDesc variants[] = { - { - "MUST", - 0, nullptr, - static_cast(std::size(MUST::deviceExtensions)), MUST::deviceExtensions, - static_cast(std::size(featureStructTypes)), featureStructTypes, - MUST::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - MUST::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - MUST::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace MUST - - namespace multisampledToSingleSampled_shaderStencilExport_ { - static const VpVariantDesc variants[] = { - { - "multisampledToSingleSampled", - 0, nullptr, - static_cast(std::size(multisampledToSingleSampled::deviceExtensions)), multisampledToSingleSampled::deviceExtensions, - 0, nullptr, - multisampledToSingleSampled::featureDesc, - 0, nullptr, - multisampledToSingleSampled::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - multisampledToSingleSampled::chainerDesc, - }, - { - "shaderStencilExport", - 0, nullptr, - static_cast(std::size(shaderStencilExport::deviceExtensions)), shaderStencilExport::deviceExtensions, - 0, nullptr, - shaderStencilExport::featureDesc, - 0, nullptr, - shaderStencilExport::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - shaderStencilExport::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace multisampledToSingleSampled_shaderStencilExport_ - - static const VpCapabilitiesDesc capabilities[] = { - { MUST::variantCount, MUST::variants }, - { multisampledToSingleSampled_shaderStencilExport_::variantCount, multisampledToSingleSampled_shaderStencilExport_::variants }, - }; - static const uint32_t capabilityCount = static_cast(std::size(capabilities)); - - static const VpProfileProperties profiles[] = { - {VP_ANDROID_BASELINE_2022_NAME, VP_ANDROID_BASELINE_2022_SPEC_VERSION}, - {VP_ANDROID_15_MINIMUMS_NAME, VP_ANDROID_15_MINIMUMS_SPEC_VERSION}, - }; - static const uint32_t profileCount = static_cast(std::size(profiles)); -} // namespace VP_ANDROID_16_MINIMUMS -#endif //VP_ANDROID_16_minimums - -#ifdef VP_ANDROID_baseline_2021 -namespace VP_ANDROID_BASELINE_2021 { - static const VpVariantDesc mergedCapabilities[] = { - { - "MERGED", - static_cast(std::size(instanceExtensions)), instanceExtensions, - static_cast(std::size(deviceExtensions)), deviceExtensions, - static_cast(std::size(featureStructTypes)), featureStructTypes, - featureDesc, - 0, nullptr, - propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - chainerDesc, - }, - }; - - namespace baseline { - static const VpVariantDesc variants[] = { - { - "baseline", - static_cast(std::size(baseline::instanceExtensions)), baseline::instanceExtensions, - static_cast(std::size(baseline::deviceExtensions)), baseline::deviceExtensions, - static_cast(std::size(featureStructTypes)), featureStructTypes, - baseline::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - baseline::propertyDesc, - 0, nullptr, - 0, nullptr, - static_cast(std::size(formatStructTypes)), formatStructTypes, - static_cast(std::size(baseline::formatDesc)), baseline::formatDesc, - baseline::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace baseline - - static const VpCapabilitiesDesc capabilities[] = { - { baseline::variantCount, baseline::variants }, - }; - static const uint32_t capabilityCount = static_cast(std::size(capabilities)); -} // namespace VP_ANDROID_BASELINE_2021 -#endif //VP_ANDROID_baseline_2021 - -#ifdef VP_ANDROID_baseline_2022 -namespace VP_ANDROID_BASELINE_2022 { - static const VpVariantDesc mergedCapabilities[] = { - { - "MERGED", - static_cast(std::size(instanceExtensions)), instanceExtensions, - static_cast(std::size(deviceExtensions)), deviceExtensions, - static_cast(std::size(featureStructTypes)), featureStructTypes, - featureDesc, - 0, nullptr, - propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - chainerDesc, - }, - }; - - namespace baseline { - static const VpVariantDesc variants[] = { - { - "baseline", - static_cast(std::size(baseline::instanceExtensions)), baseline::instanceExtensions, - static_cast(std::size(baseline::deviceExtensions)), baseline::deviceExtensions, - static_cast(std::size(featureStructTypes)), featureStructTypes, - baseline::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - baseline::propertyDesc, - 0, nullptr, - 0, nullptr, - static_cast(std::size(formatStructTypes)), formatStructTypes, - static_cast(std::size(baseline::formatDesc)), baseline::formatDesc, - baseline::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace baseline - - static const VpCapabilitiesDesc capabilities[] = { - { baseline::variantCount, baseline::variants }, - }; - static const uint32_t capabilityCount = static_cast(std::size(capabilities)); -} // namespace VP_ANDROID_BASELINE_2022 -#endif //VP_ANDROID_baseline_2022 - -#ifdef VP_KHR_roadmap_2022 -namespace VP_KHR_ROADMAP_2022 { - static const VpVariantDesc mergedCapabilities[] = { - { - "MERGED", - 0, nullptr, - static_cast(std::size(deviceExtensions)), deviceExtensions, - static_cast(std::size(featureStructTypes)), featureStructTypes, - featureDesc, - 0, nullptr, - propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - chainerDesc, - }, - }; - - namespace vulkan10requirements { - static const VpVariantDesc variants[] = { - { - "vulkan10requirements", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan10requirements::featureDesc, - 0, nullptr, - vulkan10requirements::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan10requirements::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan10requirements - - namespace vulkan10requirements_roadmap2022 { - static const VpVariantDesc variants[] = { - { - "vulkan10requirements_roadmap2022", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan10requirements_roadmap2022::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - vulkan10requirements_roadmap2022::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan10requirements_roadmap2022::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan10requirements_roadmap2022 - - namespace vulkan11requirements { - static const VpVariantDesc variants[] = { - { - "vulkan11requirements", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan11requirements::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - vulkan11requirements::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan11requirements::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan11requirements - - namespace vulkan11requirements_roadmap2022 { - static const VpVariantDesc variants[] = { - { - "vulkan11requirements_roadmap2022", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan11requirements_roadmap2022::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - vulkan11requirements_roadmap2022::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan11requirements_roadmap2022::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan11requirements_roadmap2022 - - namespace vulkan12requirements { - static const VpVariantDesc variants[] = { - { - "vulkan12requirements", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan12requirements::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - vulkan12requirements::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan12requirements::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan12requirements - - namespace vulkan12requirements_roadmap2022 { - static const VpVariantDesc variants[] = { - { - "vulkan12requirements_roadmap2022", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan12requirements_roadmap2022::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - vulkan12requirements_roadmap2022::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan12requirements_roadmap2022::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan12requirements_roadmap2022 - - namespace vulkan13requirements { - static const VpVariantDesc variants[] = { - { - "vulkan13requirements", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan13requirements::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - vulkan13requirements::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan13requirements::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan13requirements - - namespace vulkan13requirements_roadmap2022 { - static const VpVariantDesc variants[] = { - { - "vulkan13requirements_roadmap2022", - 0, nullptr, - static_cast(std::size(vulkan13requirements_roadmap2022::deviceExtensions)), vulkan13requirements_roadmap2022::deviceExtensions, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan13requirements_roadmap2022::featureDesc, - 0, nullptr, - vulkan13requirements_roadmap2022::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan13requirements_roadmap2022::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan13requirements_roadmap2022 - - static const VpCapabilitiesDesc capabilities[] = { - { vulkan10requirements::variantCount, vulkan10requirements::variants }, - { vulkan10requirements_roadmap2022::variantCount, vulkan10requirements_roadmap2022::variants }, - { vulkan11requirements::variantCount, vulkan11requirements::variants }, - { vulkan11requirements_roadmap2022::variantCount, vulkan11requirements_roadmap2022::variants }, - { vulkan12requirements::variantCount, vulkan12requirements::variants }, - { vulkan12requirements_roadmap2022::variantCount, vulkan12requirements_roadmap2022::variants }, - { vulkan13requirements::variantCount, vulkan13requirements::variants }, - { vulkan13requirements_roadmap2022::variantCount, vulkan13requirements_roadmap2022::variants }, - }; - static const uint32_t capabilityCount = static_cast(std::size(capabilities)); -} // namespace VP_KHR_ROADMAP_2022 -#endif //VP_KHR_roadmap_2022 - -#ifdef VP_KHR_roadmap_2024 -namespace VP_KHR_ROADMAP_2024 { - static const VpVariantDesc mergedCapabilities[] = { - { - "MERGED", - 0, nullptr, - static_cast(std::size(deviceExtensions)), deviceExtensions, - static_cast(std::size(featureStructTypes)), featureStructTypes, - featureDesc, - 0, nullptr, - propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - chainerDesc, - }, - }; - - namespace vulkan10requirements_roadmap2024 { - static const VpVariantDesc variants[] = { - { - "vulkan10requirements_roadmap2024", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan10requirements_roadmap2024::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - vulkan10requirements_roadmap2024::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan10requirements_roadmap2024::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan10requirements_roadmap2024 - - namespace vulkan11requirements_roadmap2024 { - static const VpVariantDesc variants[] = { - { - "vulkan11requirements_roadmap2024", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan11requirements_roadmap2024::featureDesc, - 0, nullptr, - vulkan11requirements_roadmap2024::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan11requirements_roadmap2024::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan11requirements_roadmap2024 - - namespace vulkan12requirements_roadmap2024 { - static const VpVariantDesc variants[] = { - { - "vulkan12requirements_roadmap2024", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan12requirements_roadmap2024::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - vulkan12requirements_roadmap2024::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan12requirements_roadmap2024::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan12requirements_roadmap2024 - - namespace vulkan13requirements_roadmap2024 { - static const VpVariantDesc variants[] = { - { - "vulkan13requirements_roadmap2024", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan13requirements_roadmap2024::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - vulkan13requirements_roadmap2024::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan13requirements_roadmap2024::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan13requirements_roadmap2024 - - namespace vulkanextensionrequirements_roadmap2024 { - static const VpVariantDesc variants[] = { - { - "vulkanextensionrequirements_roadmap2024", - 0, nullptr, - static_cast(std::size(vulkanextensionrequirements_roadmap2024::deviceExtensions)), vulkanextensionrequirements_roadmap2024::deviceExtensions, - 0, nullptr, - vulkanextensionrequirements_roadmap2024::featureDesc, - 0, nullptr, - vulkanextensionrequirements_roadmap2024::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkanextensionrequirements_roadmap2024::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkanextensionrequirements_roadmap2024 - - static const VpCapabilitiesDesc capabilities[] = { - { vulkan10requirements_roadmap2024::variantCount, vulkan10requirements_roadmap2024::variants }, - { vulkan11requirements_roadmap2024::variantCount, vulkan11requirements_roadmap2024::variants }, - { vulkan12requirements_roadmap2024::variantCount, vulkan12requirements_roadmap2024::variants }, - { vulkan13requirements_roadmap2024::variantCount, vulkan13requirements_roadmap2024::variants }, - { vulkanextensionrequirements_roadmap2024::variantCount, vulkanextensionrequirements_roadmap2024::variants }, - }; - static const uint32_t capabilityCount = static_cast(std::size(capabilities)); - - static const VpProfileProperties profiles[] = { - {VP_KHR_ROADMAP_2022_NAME, VP_KHR_ROADMAP_2022_SPEC_VERSION}, - }; - static const uint32_t profileCount = static_cast(std::size(profiles)); -} // namespace VP_KHR_ROADMAP_2024 -#endif //VP_KHR_roadmap_2024 - -#ifdef VP_LUNARG_minimum_requirements_1_0 -namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_0 { - static const VpVariantDesc mergedCapabilities[] = { - { - "MERGED", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - featureDesc, - 0, nullptr, - propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - chainerDesc, - }, - }; - - namespace vulkan10requirements { - static const VpVariantDesc variants[] = { - { - "vulkan10requirements", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan10requirements::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - vulkan10requirements::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan10requirements::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan10requirements - - static const VpCapabilitiesDesc capabilities[] = { - { vulkan10requirements::variantCount, vulkan10requirements::variants }, - }; - static const uint32_t capabilityCount = static_cast(std::size(capabilities)); -} // namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_0 -#endif //VP_LUNARG_minimum_requirements_1_0 - -#ifdef VP_LUNARG_minimum_requirements_1_1 -namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_1 { - static const VpVariantDesc mergedCapabilities[] = { - { - "MERGED", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - featureDesc, - 0, nullptr, - propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - chainerDesc, - }, - }; - - namespace vulkan10requirements { - static const VpVariantDesc variants[] = { - { - "vulkan10requirements", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan10requirements::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - vulkan10requirements::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan10requirements::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan10requirements - - namespace vulkan11requirements_split { - static const VpVariantDesc variants[] = { - { - "vulkan11requirements_split", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan11requirements_split::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - vulkan11requirements_split::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan11requirements_split::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan11requirements_split - - static const VpCapabilitiesDesc capabilities[] = { - { vulkan10requirements::variantCount, vulkan10requirements::variants }, - { vulkan11requirements_split::variantCount, vulkan11requirements_split::variants }, - }; - static const uint32_t capabilityCount = static_cast(std::size(capabilities)); -} // namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_1 -#endif //VP_LUNARG_minimum_requirements_1_1 - -#ifdef VP_LUNARG_minimum_requirements_1_2 -namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_2 { - static const VpVariantDesc mergedCapabilities[] = { - { - "MERGED", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - featureDesc, - 0, nullptr, - propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - chainerDesc, - }, - }; - - namespace vulkan10requirements { - static const VpVariantDesc variants[] = { - { - "vulkan10requirements", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan10requirements::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - vulkan10requirements::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan10requirements::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan10requirements - - namespace vulkan11requirements { - static const VpVariantDesc variants[] = { - { - "vulkan11requirements", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan11requirements::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - vulkan11requirements::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan11requirements::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan11requirements - - namespace vulkan12requirements { - static const VpVariantDesc variants[] = { - { - "vulkan12requirements", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan12requirements::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - vulkan12requirements::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan12requirements::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan12requirements - - static const VpCapabilitiesDesc capabilities[] = { - { vulkan10requirements::variantCount, vulkan10requirements::variants }, - { vulkan11requirements::variantCount, vulkan11requirements::variants }, - { vulkan12requirements::variantCount, vulkan12requirements::variants }, - }; - static const uint32_t capabilityCount = static_cast(std::size(capabilities)); -} // namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_2 -#endif //VP_LUNARG_minimum_requirements_1_2 - -#ifdef VP_LUNARG_minimum_requirements_1_3 -namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_3 { - static const VpVariantDesc mergedCapabilities[] = { - { - "MERGED", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - featureDesc, - 0, nullptr, - propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - chainerDesc, - }, - }; - - namespace vulkan10requirements { - static const VpVariantDesc variants[] = { - { - "vulkan10requirements", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan10requirements::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - vulkan10requirements::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan10requirements::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan10requirements - - namespace vulkan11requirements { - static const VpVariantDesc variants[] = { - { - "vulkan11requirements", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan11requirements::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - vulkan11requirements::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan11requirements::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan11requirements - - namespace vulkan12requirements { - static const VpVariantDesc variants[] = { - { - "vulkan12requirements", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan12requirements::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - vulkan12requirements::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan12requirements::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan12requirements - - namespace vulkan13requirements { - static const VpVariantDesc variants[] = { - { - "vulkan13requirements", - 0, nullptr, - 0, nullptr, - static_cast(std::size(featureStructTypes)), featureStructTypes, - vulkan13requirements::featureDesc, - static_cast(std::size(propertyStructTypes)), propertyStructTypes, - vulkan13requirements::propertyDesc, - 0, nullptr, - 0, nullptr, - 0, nullptr, - 0, nullptr, - vulkan13requirements::chainerDesc, - }, - }; - static const uint32_t variantCount = static_cast(std::size(variants)); - } // namespace vulkan13requirements - - static const VpCapabilitiesDesc capabilities[] = { - { vulkan10requirements::variantCount, vulkan10requirements::variants }, - { vulkan11requirements::variantCount, vulkan11requirements::variants }, - { vulkan12requirements::variantCount, vulkan12requirements::variants }, - { vulkan13requirements::variantCount, vulkan13requirements::variants }, - }; - static const uint32_t capabilityCount = static_cast(std::size(capabilities)); -} // namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_3 -#endif //VP_LUNARG_minimum_requirements_1_3 +static const uint32_t variantCount = static_cast(std::size(variants)); +} // namespace vulkan13requirements +} // namespace blocks + +static const VpCapabilitiesDesc capabilities[] = { + {blocks::vulkan10requirements::variantCount, blocks::vulkan10requirements::variants}, + {blocks::vulkan11requirements::variantCount, blocks::vulkan11requirements::variants}, + {blocks::vulkan12requirements::variantCount, blocks::vulkan12requirements::variants}, + {blocks::vulkan13requirements::variantCount, blocks::vulkan13requirements::variants}, +}; +static const uint32_t capabilityCount = static_cast(std::size(capabilities)); +} // namespace VP_LUNARG_MINIMUM_REQUIREMENTS_1_3 +#endif // VP_LUNARG_minimum_requirements_1_3 static const VpProfileDesc profiles[] = { #ifdef VP_ANDROID_15_minimums VpProfileDesc{ - VpProfileProperties{ VP_ANDROID_15_MINIMUMS_NAME, VP_ANDROID_15_MINIMUMS_SPEC_VERSION }, + VpProfileProperties{VP_ANDROID_15_MINIMUMS_NAME, VP_ANDROID_15_MINIMUMS_SPEC_VERSION}, VP_ANDROID_15_MINIMUMS_MIN_API_VERSION, nullptr, - VP_ANDROID_15_MINIMUMS::profileCount, VP_ANDROID_15_MINIMUMS::profiles, - VP_ANDROID_15_MINIMUMS::capabilityCount, VP_ANDROID_15_MINIMUMS::capabilities, - 0, nullptr, + VP_ANDROID_15_MINIMUMS::profileCount, + VP_ANDROID_15_MINIMUMS::profiles, + VP_ANDROID_15_MINIMUMS::capabilityCount, + VP_ANDROID_15_MINIMUMS::capabilities, + 0, + nullptr, }, -#endif // VP_ANDROID_15_MINIMUMS +#endif // VP_ANDROID_15_MINIMUMS #ifdef VP_ANDROID_16_minimums VpProfileDesc{ - VpProfileProperties{ VP_ANDROID_16_MINIMUMS_NAME, VP_ANDROID_16_MINIMUMS_SPEC_VERSION }, + VpProfileProperties{VP_ANDROID_16_MINIMUMS_NAME, VP_ANDROID_16_MINIMUMS_SPEC_VERSION}, VP_ANDROID_16_MINIMUMS_MIN_API_VERSION, nullptr, - VP_ANDROID_16_MINIMUMS::profileCount, VP_ANDROID_16_MINIMUMS::profiles, - VP_ANDROID_16_MINIMUMS::capabilityCount, VP_ANDROID_16_MINIMUMS::capabilities, - 0, nullptr, + VP_ANDROID_16_MINIMUMS::profileCount, + VP_ANDROID_16_MINIMUMS::profiles, + VP_ANDROID_16_MINIMUMS::capabilityCount, + VP_ANDROID_16_MINIMUMS::capabilities, + 0, + nullptr, }, -#endif // VP_ANDROID_16_MINIMUMS +#endif // VP_ANDROID_16_MINIMUMS #ifdef VP_ANDROID_baseline_2021 VpProfileDesc{ - VpProfileProperties{ VP_ANDROID_BASELINE_2021_NAME, VP_ANDROID_BASELINE_2021_SPEC_VERSION }, + VpProfileProperties{VP_ANDROID_BASELINE_2021_NAME, VP_ANDROID_BASELINE_2021_SPEC_VERSION}, VP_ANDROID_BASELINE_2021_MIN_API_VERSION, VP_ANDROID_BASELINE_2021::mergedCapabilities, - 0, nullptr, - VP_ANDROID_BASELINE_2021::capabilityCount, VP_ANDROID_BASELINE_2021::capabilities, - 0, nullptr, + 0, + nullptr, + VP_ANDROID_BASELINE_2021::capabilityCount, + VP_ANDROID_BASELINE_2021::capabilities, + 0, + nullptr, }, -#endif // VP_ANDROID_BASELINE_2021 +#endif // VP_ANDROID_BASELINE_2021 #ifdef VP_ANDROID_baseline_2022 VpProfileDesc{ - VpProfileProperties{ VP_ANDROID_BASELINE_2022_NAME, VP_ANDROID_BASELINE_2022_SPEC_VERSION }, + VpProfileProperties{VP_ANDROID_BASELINE_2022_NAME, VP_ANDROID_BASELINE_2022_SPEC_VERSION}, VP_ANDROID_BASELINE_2022_MIN_API_VERSION, VP_ANDROID_BASELINE_2022::mergedCapabilities, - 0, nullptr, - VP_ANDROID_BASELINE_2022::capabilityCount, VP_ANDROID_BASELINE_2022::capabilities, - 0, nullptr, + 0, + nullptr, + VP_ANDROID_BASELINE_2022::capabilityCount, + VP_ANDROID_BASELINE_2022::capabilities, + 0, + nullptr, }, -#endif // VP_ANDROID_BASELINE_2022 +#endif // VP_ANDROID_BASELINE_2022 #ifdef VP_KHR_roadmap_2022 VpProfileDesc{ - VpProfileProperties{ VP_KHR_ROADMAP_2022_NAME, VP_KHR_ROADMAP_2022_SPEC_VERSION }, + VpProfileProperties{VP_KHR_ROADMAP_2022_NAME, VP_KHR_ROADMAP_2022_SPEC_VERSION}, VP_KHR_ROADMAP_2022_MIN_API_VERSION, VP_KHR_ROADMAP_2022::mergedCapabilities, - 0, nullptr, - VP_KHR_ROADMAP_2022::capabilityCount, VP_KHR_ROADMAP_2022::capabilities, - 0, nullptr, + 0, + nullptr, + VP_KHR_ROADMAP_2022::capabilityCount, + VP_KHR_ROADMAP_2022::capabilities, + 0, + nullptr, }, -#endif // VP_KHR_ROADMAP_2022 +#endif // VP_KHR_ROADMAP_2022 #ifdef VP_KHR_roadmap_2024 VpProfileDesc{ - VpProfileProperties{ VP_KHR_ROADMAP_2024_NAME, VP_KHR_ROADMAP_2024_SPEC_VERSION }, + VpProfileProperties{VP_KHR_ROADMAP_2024_NAME, VP_KHR_ROADMAP_2024_SPEC_VERSION}, VP_KHR_ROADMAP_2024_MIN_API_VERSION, VP_KHR_ROADMAP_2024::mergedCapabilities, - VP_KHR_ROADMAP_2024::profileCount, VP_KHR_ROADMAP_2024::profiles, - VP_KHR_ROADMAP_2024::capabilityCount, VP_KHR_ROADMAP_2024::capabilities, - 0, nullptr, + VP_KHR_ROADMAP_2024::profileCount, + VP_KHR_ROADMAP_2024::profiles, + VP_KHR_ROADMAP_2024::capabilityCount, + VP_KHR_ROADMAP_2024::capabilities, + 0, + nullptr, + }, +#endif // VP_KHR_ROADMAP_2024 +#ifdef VP_LUNARG_desktop_baseline_2022 + VpProfileDesc{ + VpProfileProperties{VP_LUNARG_DESKTOP_BASELINE_2022_NAME, VP_LUNARG_DESKTOP_BASELINE_2022_SPEC_VERSION}, + VP_LUNARG_DESKTOP_BASELINE_2022_MIN_API_VERSION, + VP_LUNARG_DESKTOP_BASELINE_2022::mergedCapabilities, + 0, + nullptr, + VP_LUNARG_DESKTOP_BASELINE_2022::capabilityCount, + VP_LUNARG_DESKTOP_BASELINE_2022::capabilities, + 0, + nullptr, + }, +#endif // VP_LUNARG_DESKTOP_BASELINE_2022 +#ifdef VP_LUNARG_desktop_baseline_2023 + VpProfileDesc{ + VpProfileProperties{VP_LUNARG_DESKTOP_BASELINE_2023_NAME, VP_LUNARG_DESKTOP_BASELINE_2023_SPEC_VERSION}, + VP_LUNARG_DESKTOP_BASELINE_2023_MIN_API_VERSION, + VP_LUNARG_DESKTOP_BASELINE_2023::mergedCapabilities, + 0, + nullptr, + VP_LUNARG_DESKTOP_BASELINE_2023::capabilityCount, + VP_LUNARG_DESKTOP_BASELINE_2023::capabilities, + 0, + nullptr, + }, +#endif // VP_LUNARG_DESKTOP_BASELINE_2023 +#ifdef VP_LUNARG_desktop_baseline_2024 + VpProfileDesc{ + VpProfileProperties{VP_LUNARG_DESKTOP_BASELINE_2024_NAME, VP_LUNARG_DESKTOP_BASELINE_2024_SPEC_VERSION}, + VP_LUNARG_DESKTOP_BASELINE_2024_MIN_API_VERSION, + VP_LUNARG_DESKTOP_BASELINE_2024::mergedCapabilities, + 0, + nullptr, + VP_LUNARG_DESKTOP_BASELINE_2024::capabilityCount, + VP_LUNARG_DESKTOP_BASELINE_2024::capabilities, + 0, + nullptr, }, -#endif // VP_KHR_ROADMAP_2024 +#endif // VP_LUNARG_DESKTOP_BASELINE_2024 #ifdef VP_LUNARG_minimum_requirements_1_0 VpProfileDesc{ - VpProfileProperties{ VP_LUNARG_MINIMUM_REQUIREMENTS_1_0_NAME, VP_LUNARG_MINIMUM_REQUIREMENTS_1_0_SPEC_VERSION }, + VpProfileProperties{VP_LUNARG_MINIMUM_REQUIREMENTS_1_0_NAME, VP_LUNARG_MINIMUM_REQUIREMENTS_1_0_SPEC_VERSION}, VP_LUNARG_MINIMUM_REQUIREMENTS_1_0_MIN_API_VERSION, VP_LUNARG_MINIMUM_REQUIREMENTS_1_0::mergedCapabilities, - 0, nullptr, - VP_LUNARG_MINIMUM_REQUIREMENTS_1_0::capabilityCount, VP_LUNARG_MINIMUM_REQUIREMENTS_1_0::capabilities, - 0, nullptr, + 0, + nullptr, + VP_LUNARG_MINIMUM_REQUIREMENTS_1_0::capabilityCount, + VP_LUNARG_MINIMUM_REQUIREMENTS_1_0::capabilities, + 0, + nullptr, }, -#endif // VP_LUNARG_MINIMUM_REQUIREMENTS_1_0 +#endif // VP_LUNARG_MINIMUM_REQUIREMENTS_1_0 #ifdef VP_LUNARG_minimum_requirements_1_1 VpProfileDesc{ - VpProfileProperties{ VP_LUNARG_MINIMUM_REQUIREMENTS_1_1_NAME, VP_LUNARG_MINIMUM_REQUIREMENTS_1_1_SPEC_VERSION }, + VpProfileProperties{VP_LUNARG_MINIMUM_REQUIREMENTS_1_1_NAME, VP_LUNARG_MINIMUM_REQUIREMENTS_1_1_SPEC_VERSION}, VP_LUNARG_MINIMUM_REQUIREMENTS_1_1_MIN_API_VERSION, VP_LUNARG_MINIMUM_REQUIREMENTS_1_1::mergedCapabilities, - 0, nullptr, - VP_LUNARG_MINIMUM_REQUIREMENTS_1_1::capabilityCount, VP_LUNARG_MINIMUM_REQUIREMENTS_1_1::capabilities, - 0, nullptr, + 0, + nullptr, + VP_LUNARG_MINIMUM_REQUIREMENTS_1_1::capabilityCount, + VP_LUNARG_MINIMUM_REQUIREMENTS_1_1::capabilities, + 0, + nullptr, }, -#endif // VP_LUNARG_MINIMUM_REQUIREMENTS_1_1 +#endif // VP_LUNARG_MINIMUM_REQUIREMENTS_1_1 #ifdef VP_LUNARG_minimum_requirements_1_2 VpProfileDesc{ - VpProfileProperties{ VP_LUNARG_MINIMUM_REQUIREMENTS_1_2_NAME, VP_LUNARG_MINIMUM_REQUIREMENTS_1_2_SPEC_VERSION }, + VpProfileProperties{VP_LUNARG_MINIMUM_REQUIREMENTS_1_2_NAME, VP_LUNARG_MINIMUM_REQUIREMENTS_1_2_SPEC_VERSION}, VP_LUNARG_MINIMUM_REQUIREMENTS_1_2_MIN_API_VERSION, VP_LUNARG_MINIMUM_REQUIREMENTS_1_2::mergedCapabilities, - 0, nullptr, - VP_LUNARG_MINIMUM_REQUIREMENTS_1_2::capabilityCount, VP_LUNARG_MINIMUM_REQUIREMENTS_1_2::capabilities, - 0, nullptr, + 0, + nullptr, + VP_LUNARG_MINIMUM_REQUIREMENTS_1_2::capabilityCount, + VP_LUNARG_MINIMUM_REQUIREMENTS_1_2::capabilities, + 0, + nullptr, }, -#endif // VP_LUNARG_MINIMUM_REQUIREMENTS_1_2 +#endif // VP_LUNARG_MINIMUM_REQUIREMENTS_1_2 #ifdef VP_LUNARG_minimum_requirements_1_3 VpProfileDesc{ - VpProfileProperties{ VP_LUNARG_MINIMUM_REQUIREMENTS_1_3_NAME, VP_LUNARG_MINIMUM_REQUIREMENTS_1_3_SPEC_VERSION }, + VpProfileProperties{VP_LUNARG_MINIMUM_REQUIREMENTS_1_3_NAME, VP_LUNARG_MINIMUM_REQUIREMENTS_1_3_SPEC_VERSION}, VP_LUNARG_MINIMUM_REQUIREMENTS_1_3_MIN_API_VERSION, VP_LUNARG_MINIMUM_REQUIREMENTS_1_3::mergedCapabilities, - 0, nullptr, - VP_LUNARG_MINIMUM_REQUIREMENTS_1_3::capabilityCount, VP_LUNARG_MINIMUM_REQUIREMENTS_1_3::capabilities, - 0, nullptr, + 0, + nullptr, + VP_LUNARG_MINIMUM_REQUIREMENTS_1_3::capabilityCount, + VP_LUNARG_MINIMUM_REQUIREMENTS_1_3::capabilities, + 0, + nullptr, }, -#endif // VP_LUNARG_MINIMUM_REQUIREMENTS_1_3 +#endif // VP_LUNARG_MINIMUM_REQUIREMENTS_1_3 }; static const uint32_t profileCount = static_cast(std::size(profiles)); +struct FeaturesChain +{ + std::map structureSize; -struct FeaturesChain { - std::map structureSize; - - template - constexpr std::size_t size() const { - return (sizeof(T) - sizeof(VkBaseOutStructure)) / sizeof(VkBool32); - } + template + constexpr std::size_t size() const + { + return (sizeof(T) - sizeof(VkBaseOutStructure)) / sizeof(VkBool32); + } // Chain with all Vulkan Features structures - VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV physicalDeviceDeviceGeneratedCommandsFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV, nullptr }; - VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV, nullptr }; - VkPhysicalDevicePrivateDataFeatures physicalDevicePrivateDataFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, nullptr }; - VkPhysicalDeviceVariablePointersFeatures physicalDeviceVariablePointersFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, nullptr }; - VkPhysicalDeviceMultiviewFeatures physicalDeviceMultiviewFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, nullptr }; - VkPhysicalDevicePresentIdFeaturesKHR physicalDevicePresentIdFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR, nullptr }; - VkPhysicalDevicePresentWaitFeaturesKHR physicalDevicePresentWaitFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR, nullptr }; - VkPhysicalDevice16BitStorageFeatures physicalDevice16BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, nullptr }; - VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures physicalDeviceShaderSubgroupExtendedTypesFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, nullptr }; - VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, nullptr }; - VkPhysicalDeviceProtectedMemoryFeatures physicalDeviceProtectedMemoryFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, nullptr }; - VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT physicalDeviceBlendOperationAdvancedFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, nullptr }; - VkPhysicalDeviceMultiDrawFeaturesEXT physicalDeviceMultiDrawFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT, nullptr }; - VkPhysicalDeviceInlineUniformBlockFeatures physicalDeviceInlineUniformBlockFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES, nullptr }; - VkPhysicalDeviceMaintenance4Features physicalDeviceMaintenance4Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, nullptr }; - VkPhysicalDeviceMaintenance5FeaturesKHR physicalDeviceMaintenance5FeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR, nullptr }; - VkPhysicalDeviceMaintenance6FeaturesKHR physicalDeviceMaintenance6FeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR, nullptr }; - VkPhysicalDeviceMaintenance7FeaturesKHR physicalDeviceMaintenance7FeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR, nullptr }; - VkPhysicalDeviceShaderDrawParametersFeatures physicalDeviceShaderDrawParametersFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, nullptr }; - VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, nullptr }; - VkPhysicalDeviceHostQueryResetFeatures physicalDeviceHostQueryResetFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, nullptr }; - VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR physicalDeviceGlobalPriorityQueryFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR, nullptr }; - VkPhysicalDeviceDeviceMemoryReportFeaturesEXT physicalDeviceDeviceMemoryReportFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT, nullptr }; - VkPhysicalDeviceDescriptorIndexingFeatures physicalDeviceDescriptorIndexingFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, nullptr }; - VkPhysicalDeviceTimelineSemaphoreFeatures physicalDeviceTimelineSemaphoreFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, nullptr }; - VkPhysicalDevice8BitStorageFeatures physicalDevice8BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, nullptr }; - VkPhysicalDeviceConditionalRenderingFeaturesEXT physicalDeviceConditionalRenderingFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, nullptr }; - VkPhysicalDeviceVulkanMemoryModelFeatures physicalDeviceVulkanMemoryModelFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, nullptr }; - VkPhysicalDeviceShaderAtomicInt64Features physicalDeviceShaderAtomicInt64Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, nullptr }; - VkPhysicalDeviceShaderAtomicFloatFeaturesEXT physicalDeviceShaderAtomicFloatFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT, nullptr }; - VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT physicalDeviceShaderAtomicFloat2FeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT, nullptr }; - VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR physicalDeviceVertexAttributeDivisorFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, nullptr }; - VkPhysicalDeviceASTCDecodeFeaturesEXT physicalDeviceASTCDecodeFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT, nullptr }; - VkPhysicalDeviceTransformFeedbackFeaturesEXT physicalDeviceTransformFeedbackFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, nullptr }; - VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV physicalDeviceRepresentativeFragmentTestFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, nullptr }; - VkPhysicalDeviceExclusiveScissorFeaturesNV physicalDeviceExclusiveScissorFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, nullptr }; - VkPhysicalDeviceCornerSampledImageFeaturesNV physicalDeviceCornerSampledImageFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, nullptr }; - VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR physicalDeviceComputeShaderDerivativesFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR, nullptr }; - VkPhysicalDeviceShaderImageFootprintFeaturesNV physicalDeviceShaderImageFootprintFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV, nullptr }; - VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV physicalDeviceDedicatedAllocationImageAliasingFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, nullptr }; - VkPhysicalDeviceCopyMemoryIndirectFeaturesNV physicalDeviceCopyMemoryIndirectFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV, nullptr }; - VkPhysicalDeviceMemoryDecompressionFeaturesNV physicalDeviceMemoryDecompressionFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV, nullptr }; - VkPhysicalDeviceShadingRateImageFeaturesNV physicalDeviceShadingRateImageFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, nullptr }; - VkPhysicalDeviceInvocationMaskFeaturesHUAWEI physicalDeviceInvocationMaskFeaturesHUAWEI{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI, nullptr }; - VkPhysicalDeviceMeshShaderFeaturesNV physicalDeviceMeshShaderFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, nullptr }; - VkPhysicalDeviceMeshShaderFeaturesEXT physicalDeviceMeshShaderFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT, nullptr }; - VkPhysicalDeviceAccelerationStructureFeaturesKHR physicalDeviceAccelerationStructureFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR, nullptr }; - VkPhysicalDeviceRayTracingPipelineFeaturesKHR physicalDeviceRayTracingPipelineFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR, nullptr }; - VkPhysicalDeviceRayQueryFeaturesKHR physicalDeviceRayQueryFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR, nullptr }; - VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR physicalDeviceRayTracingMaintenance1FeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR, nullptr }; - VkPhysicalDeviceFragmentDensityMapFeaturesEXT physicalDeviceFragmentDensityMapFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, nullptr }; - VkPhysicalDeviceFragmentDensityMap2FeaturesEXT physicalDeviceFragmentDensityMap2FeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT, nullptr }; - VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM physicalDeviceFragmentDensityMapOffsetFeaturesQCOM{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM, nullptr }; - VkPhysicalDeviceScalarBlockLayoutFeatures physicalDeviceScalarBlockLayoutFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, nullptr }; - VkPhysicalDeviceUniformBufferStandardLayoutFeatures physicalDeviceUniformBufferStandardLayoutFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, nullptr }; - VkPhysicalDeviceDepthClipEnableFeaturesEXT physicalDeviceDepthClipEnableFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, nullptr }; - VkPhysicalDeviceMemoryPriorityFeaturesEXT physicalDeviceMemoryPriorityFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, nullptr }; - VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT physicalDevicePageableDeviceLocalMemoryFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT, nullptr }; - VkPhysicalDeviceBufferDeviceAddressFeatures physicalDeviceBufferDeviceAddressFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, nullptr }; - VkPhysicalDeviceBufferDeviceAddressFeaturesEXT physicalDeviceBufferDeviceAddressFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, nullptr }; - VkPhysicalDeviceImagelessFramebufferFeatures physicalDeviceImagelessFramebufferFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, nullptr }; - VkPhysicalDeviceTextureCompressionASTCHDRFeatures physicalDeviceTextureCompressionASTCHDRFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES, nullptr }; - VkPhysicalDeviceCooperativeMatrixFeaturesNV physicalDeviceCooperativeMatrixFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, nullptr }; - VkPhysicalDeviceYcbcrImageArraysFeaturesEXT physicalDeviceYcbcrImageArraysFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT, nullptr }; - VkPhysicalDevicePresentBarrierFeaturesNV physicalDevicePresentBarrierFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV, nullptr }; - VkPhysicalDevicePerformanceQueryFeaturesKHR physicalDevicePerformanceQueryFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, nullptr }; - VkPhysicalDeviceCoverageReductionModeFeaturesNV physicalDeviceCoverageReductionModeFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, nullptr }; - VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL physicalDeviceShaderIntegerFunctions2FeaturesINTEL{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL, nullptr }; - VkPhysicalDeviceShaderClockFeaturesKHR physicalDeviceShaderClockFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, nullptr }; - VkPhysicalDeviceIndexTypeUint8FeaturesKHR physicalDeviceIndexTypeUint8FeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR, nullptr }; - VkPhysicalDeviceShaderSMBuiltinsFeaturesNV physicalDeviceShaderSMBuiltinsFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV, nullptr }; - VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT physicalDeviceFragmentShaderInterlockFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, nullptr }; - VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures physicalDeviceSeparateDepthStencilLayoutsFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, nullptr }; - VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT physicalDevicePrimitiveTopologyListRestartFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, nullptr }; - VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR physicalDevicePipelineExecutablePropertiesFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, nullptr }; - VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures physicalDeviceShaderDemoteToHelperInvocationFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, nullptr }; - VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT physicalDeviceTexelBufferAlignmentFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, nullptr }; - VkPhysicalDeviceSubgroupSizeControlFeatures physicalDeviceSubgroupSizeControlFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES, nullptr }; - VkPhysicalDeviceLineRasterizationFeaturesKHR physicalDeviceLineRasterizationFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR, nullptr }; - VkPhysicalDevicePipelineCreationCacheControlFeatures physicalDevicePipelineCreationCacheControlFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, nullptr }; - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr }; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr }; - VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, nullptr }; - VkPhysicalDeviceCoherentMemoryFeaturesAMD physicalDeviceCoherentMemoryFeaturesAMD{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, nullptr }; - VkPhysicalDeviceCustomBorderColorFeaturesEXT physicalDeviceCustomBorderColorFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, nullptr }; - VkPhysicalDeviceBorderColorSwizzleFeaturesEXT physicalDeviceBorderColorSwizzleFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT, nullptr }; - VkPhysicalDeviceExtendedDynamicStateFeaturesEXT physicalDeviceExtendedDynamicStateFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT, nullptr }; - VkPhysicalDeviceExtendedDynamicState2FeaturesEXT physicalDeviceExtendedDynamicState2FeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT, nullptr }; - VkPhysicalDeviceExtendedDynamicState3FeaturesEXT physicalDeviceExtendedDynamicState3FeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT, nullptr }; - VkPhysicalDeviceDiagnosticsConfigFeaturesNV physicalDeviceDiagnosticsConfigFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV, nullptr }; - VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures physicalDeviceZeroInitializeWorkgroupMemoryFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES, nullptr }; - VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, nullptr }; - VkPhysicalDeviceRobustness2FeaturesEXT physicalDeviceRobustness2FeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, nullptr }; - VkPhysicalDeviceImageRobustnessFeatures physicalDeviceImageRobustnessFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES, nullptr }; - VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR, nullptr }; + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV physicalDeviceDeviceGeneratedCommandsFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV, nullptr}; + VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV, nullptr}; + VkPhysicalDevicePrivateDataFeatures physicalDevicePrivateDataFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, nullptr}; + VkPhysicalDeviceClusterAccelerationStructureFeaturesNV physicalDeviceClusterAccelerationStructureFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV, nullptr}; + VkPhysicalDeviceVariablePointersFeatures physicalDeviceVariablePointersFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, nullptr}; + VkPhysicalDeviceMultiviewFeatures physicalDeviceMultiviewFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, nullptr}; + VkPhysicalDevicePresentIdFeaturesKHR physicalDevicePresentIdFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR, nullptr}; + VkPhysicalDevicePresentId2FeaturesKHR physicalDevicePresentId2FeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR, nullptr}; + VkPhysicalDevicePresentWaitFeaturesKHR physicalDevicePresentWaitFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR, nullptr}; + VkPhysicalDevicePresentWait2FeaturesKHR physicalDevicePresentWait2FeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR, nullptr}; + VkPhysicalDevice16BitStorageFeatures physicalDevice16BitStorageFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, nullptr}; + VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures physicalDeviceShaderSubgroupExtendedTypesFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, nullptr}; + VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, nullptr}; + VkPhysicalDeviceProtectedMemoryFeatures physicalDeviceProtectedMemoryFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, nullptr}; + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT physicalDeviceBlendOperationAdvancedFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, nullptr}; + VkPhysicalDeviceMultiDrawFeaturesEXT physicalDeviceMultiDrawFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT, nullptr}; + VkPhysicalDeviceInlineUniformBlockFeatures physicalDeviceInlineUniformBlockFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES, nullptr}; + VkPhysicalDeviceMaintenance4Features physicalDeviceMaintenance4Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, nullptr}; + VkPhysicalDeviceMaintenance5Features physicalDeviceMaintenance5Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES, nullptr}; + VkPhysicalDeviceMaintenance6Features physicalDeviceMaintenance6Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES, nullptr}; + VkPhysicalDeviceMaintenance7FeaturesKHR physicalDeviceMaintenance7FeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR, nullptr}; + VkPhysicalDeviceMaintenance8FeaturesKHR physicalDeviceMaintenance8FeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR, nullptr}; + VkPhysicalDeviceMaintenance9FeaturesKHR physicalDeviceMaintenance9FeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR, nullptr}; + VkPhysicalDeviceShaderDrawParametersFeatures physicalDeviceShaderDrawParametersFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, nullptr}; + VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, nullptr}; + VkPhysicalDeviceHostQueryResetFeatures physicalDeviceHostQueryResetFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, nullptr}; + VkPhysicalDeviceGlobalPriorityQueryFeatures physicalDeviceGlobalPriorityQueryFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES, nullptr}; + VkPhysicalDeviceDeviceMemoryReportFeaturesEXT physicalDeviceDeviceMemoryReportFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT, nullptr}; + VkPhysicalDeviceDescriptorIndexingFeatures physicalDeviceDescriptorIndexingFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, nullptr}; + VkPhysicalDeviceTimelineSemaphoreFeatures physicalDeviceTimelineSemaphoreFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, nullptr}; + VkPhysicalDevice8BitStorageFeatures physicalDevice8BitStorageFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, nullptr}; + VkPhysicalDeviceConditionalRenderingFeaturesEXT physicalDeviceConditionalRenderingFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, nullptr}; + VkPhysicalDeviceVulkanMemoryModelFeatures physicalDeviceVulkanMemoryModelFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, nullptr}; + VkPhysicalDeviceShaderAtomicInt64Features physicalDeviceShaderAtomicInt64Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, nullptr}; + VkPhysicalDeviceShaderAtomicFloatFeaturesEXT physicalDeviceShaderAtomicFloatFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT, nullptr}; + VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT physicalDeviceShaderAtomicFloat2FeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT, nullptr}; + VkPhysicalDeviceVertexAttributeDivisorFeatures physicalDeviceVertexAttributeDivisorFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES, nullptr}; + VkPhysicalDeviceASTCDecodeFeaturesEXT physicalDeviceASTCDecodeFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT, nullptr}; + VkPhysicalDeviceTransformFeedbackFeaturesEXT physicalDeviceTransformFeedbackFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, nullptr}; + VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV physicalDeviceRepresentativeFragmentTestFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, nullptr}; + VkPhysicalDeviceExclusiveScissorFeaturesNV physicalDeviceExclusiveScissorFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, nullptr}; + VkPhysicalDeviceCornerSampledImageFeaturesNV physicalDeviceCornerSampledImageFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, nullptr}; + VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR physicalDeviceComputeShaderDerivativesFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR, nullptr}; + VkPhysicalDeviceShaderImageFootprintFeaturesNV physicalDeviceShaderImageFootprintFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV, nullptr}; + VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV physicalDeviceDedicatedAllocationImageAliasingFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, nullptr}; + VkPhysicalDeviceCopyMemoryIndirectFeaturesNV physicalDeviceCopyMemoryIndirectFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV, nullptr}; + VkPhysicalDeviceMemoryDecompressionFeaturesNV physicalDeviceMemoryDecompressionFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV, nullptr}; + VkPhysicalDeviceShadingRateImageFeaturesNV physicalDeviceShadingRateImageFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, nullptr}; + VkPhysicalDeviceInvocationMaskFeaturesHUAWEI physicalDeviceInvocationMaskFeaturesHUAWEI{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI, nullptr}; + VkPhysicalDeviceMeshShaderFeaturesNV physicalDeviceMeshShaderFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, nullptr}; + VkPhysicalDeviceMeshShaderFeaturesEXT physicalDeviceMeshShaderFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT, nullptr}; + VkPhysicalDeviceAccelerationStructureFeaturesKHR physicalDeviceAccelerationStructureFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR, nullptr}; + VkPhysicalDeviceRayTracingPipelineFeaturesKHR physicalDeviceRayTracingPipelineFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR, nullptr}; + VkPhysicalDeviceRayQueryFeaturesKHR physicalDeviceRayQueryFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR, nullptr}; + VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR physicalDeviceRayTracingMaintenance1FeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR, nullptr}; + VkPhysicalDeviceFragmentDensityMapFeaturesEXT physicalDeviceFragmentDensityMapFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, nullptr}; + VkPhysicalDeviceFragmentDensityMap2FeaturesEXT physicalDeviceFragmentDensityMap2FeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT, nullptr}; + VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT physicalDeviceFragmentDensityMapOffsetFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT, nullptr}; + VkPhysicalDeviceScalarBlockLayoutFeatures physicalDeviceScalarBlockLayoutFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, nullptr}; + VkPhysicalDeviceUniformBufferStandardLayoutFeatures physicalDeviceUniformBufferStandardLayoutFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, nullptr}; + VkPhysicalDeviceDepthClipEnableFeaturesEXT physicalDeviceDepthClipEnableFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, nullptr}; + VkPhysicalDeviceMemoryPriorityFeaturesEXT physicalDeviceMemoryPriorityFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, nullptr}; + VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT physicalDevicePageableDeviceLocalMemoryFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT, nullptr}; + VkPhysicalDeviceBufferDeviceAddressFeatures physicalDeviceBufferDeviceAddressFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, nullptr}; + VkPhysicalDeviceBufferDeviceAddressFeaturesEXT physicalDeviceBufferDeviceAddressFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, nullptr}; + VkPhysicalDeviceImagelessFramebufferFeatures physicalDeviceImagelessFramebufferFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, nullptr}; + VkPhysicalDeviceTextureCompressionASTCHDRFeatures physicalDeviceTextureCompressionASTCHDRFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES, nullptr}; + VkPhysicalDeviceCooperativeMatrixFeaturesNV physicalDeviceCooperativeMatrixFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, nullptr}; + VkPhysicalDeviceYcbcrImageArraysFeaturesEXT physicalDeviceYcbcrImageArraysFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT, nullptr}; + VkPhysicalDevicePresentBarrierFeaturesNV physicalDevicePresentBarrierFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV, nullptr}; + VkPhysicalDevicePerformanceQueryFeaturesKHR physicalDevicePerformanceQueryFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, nullptr}; + VkPhysicalDeviceCoverageReductionModeFeaturesNV physicalDeviceCoverageReductionModeFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, nullptr}; + VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL physicalDeviceShaderIntegerFunctions2FeaturesINTEL{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL, nullptr}; + VkPhysicalDeviceShaderClockFeaturesKHR physicalDeviceShaderClockFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, nullptr}; + VkPhysicalDeviceIndexTypeUint8Features physicalDeviceIndexTypeUint8Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES, nullptr}; + VkPhysicalDeviceShaderSMBuiltinsFeaturesNV physicalDeviceShaderSMBuiltinsFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV, nullptr}; + VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT physicalDeviceFragmentShaderInterlockFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, nullptr}; + VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures physicalDeviceSeparateDepthStencilLayoutsFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, nullptr}; + VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT physicalDevicePrimitiveTopologyListRestartFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, nullptr}; + VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR physicalDevicePipelineExecutablePropertiesFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, nullptr}; + VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures physicalDeviceShaderDemoteToHelperInvocationFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, nullptr}; + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT physicalDeviceTexelBufferAlignmentFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, nullptr}; + VkPhysicalDeviceSubgroupSizeControlFeatures physicalDeviceSubgroupSizeControlFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES, nullptr}; + VkPhysicalDeviceLineRasterizationFeatures physicalDeviceLineRasterizationFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES, nullptr}; + VkPhysicalDevicePipelineCreationCacheControlFeatures physicalDevicePipelineCreationCacheControlFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, nullptr}; + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, nullptr}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr}; + VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, nullptr}; + VkPhysicalDeviceVulkan14Features physicalDeviceVulkan14Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES, nullptr}; + VkPhysicalDeviceCoherentMemoryFeaturesAMD physicalDeviceCoherentMemoryFeaturesAMD{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, nullptr}; + VkPhysicalDeviceCustomBorderColorFeaturesEXT physicalDeviceCustomBorderColorFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, nullptr}; + VkPhysicalDeviceBorderColorSwizzleFeaturesEXT physicalDeviceBorderColorSwizzleFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT, nullptr}; + VkPhysicalDeviceExtendedDynamicStateFeaturesEXT physicalDeviceExtendedDynamicStateFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT, nullptr}; + VkPhysicalDeviceExtendedDynamicState2FeaturesEXT physicalDeviceExtendedDynamicState2FeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT, nullptr}; + VkPhysicalDeviceExtendedDynamicState3FeaturesEXT physicalDeviceExtendedDynamicState3FeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT, nullptr}; + VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV physicalDevicePartitionedAccelerationStructureFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV, nullptr}; + VkPhysicalDeviceDiagnosticsConfigFeaturesNV physicalDeviceDiagnosticsConfigFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV, nullptr}; + VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures physicalDeviceZeroInitializeWorkgroupMemoryFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES, nullptr}; + VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, nullptr}; + VkPhysicalDeviceRobustness2FeaturesKHR physicalDeviceRobustness2FeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR, nullptr}; + VkPhysicalDeviceImageRobustnessFeatures physicalDeviceImageRobustnessFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES, nullptr}; + VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR, nullptr}; #ifdef VK_ENABLE_BETA_EXTENSIONS - VkPhysicalDevicePortabilitySubsetFeaturesKHR physicalDevicePortabilitySubsetFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR, nullptr }; + VkPhysicalDevicePortabilitySubsetFeaturesKHR physicalDevicePortabilitySubsetFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR, nullptr}; #endif - VkPhysicalDevice4444FormatsFeaturesEXT physicalDevice4444FormatsFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT, nullptr }; - VkPhysicalDeviceSubpassShadingFeaturesHUAWEI physicalDeviceSubpassShadingFeaturesHUAWEI{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI, nullptr }; - VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI physicalDeviceClusterCullingShaderFeaturesHUAWEI{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI, nullptr }; - VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT physicalDeviceShaderImageAtomicInt64FeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT, nullptr }; - VkPhysicalDeviceFragmentShadingRateFeaturesKHR physicalDeviceFragmentShadingRateFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR, nullptr }; - VkPhysicalDeviceShaderTerminateInvocationFeatures physicalDeviceShaderTerminateInvocationFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, nullptr }; - VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV physicalDeviceFragmentShadingRateEnumsFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV, nullptr }; - VkPhysicalDeviceImage2DViewOf3DFeaturesEXT physicalDeviceImage2DViewOf3DFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, nullptr }; - VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT physicalDeviceImageSlicedViewOf3DFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT, nullptr }; - VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT, nullptr }; - VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT physicalDeviceLegacyVertexAttributesFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT, nullptr }; - VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT physicalDeviceMutableDescriptorTypeFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, nullptr }; - VkPhysicalDeviceDepthClipControlFeaturesEXT physicalDeviceDepthClipControlFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT, nullptr }; - VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT physicalDeviceDeviceGeneratedCommandsFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT, nullptr }; - VkPhysicalDeviceDepthClampControlFeaturesEXT physicalDeviceDepthClampControlFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT, nullptr }; - VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT physicalDeviceVertexInputDynamicStateFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT, nullptr }; - VkPhysicalDeviceExternalMemoryRDMAFeaturesNV physicalDeviceExternalMemoryRDMAFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV, nullptr }; - VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR, nullptr }; - VkPhysicalDeviceColorWriteEnableFeaturesEXT physicalDeviceColorWriteEnableFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT, nullptr }; - VkPhysicalDeviceSynchronization2Features physicalDeviceSynchronization2Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES, nullptr }; - VkPhysicalDeviceHostImageCopyFeaturesEXT physicalDeviceHostImageCopyFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT, nullptr }; - VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT physicalDevicePrimitivesGeneratedQueryFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, nullptr }; - VkPhysicalDeviceLegacyDitheringFeaturesEXT physicalDeviceLegacyDitheringFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT, nullptr }; - VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT, nullptr }; - VkPhysicalDevicePipelineProtectedAccessFeaturesEXT physicalDevicePipelineProtectedAccessFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT, nullptr }; - VkPhysicalDeviceVideoMaintenance1FeaturesKHR physicalDeviceVideoMaintenance1FeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR, nullptr }; - VkPhysicalDeviceInheritedViewportScissorFeaturesNV physicalDeviceInheritedViewportScissorFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV, nullptr }; - VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT physicalDeviceYcbcr2Plane444FormatsFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT, nullptr }; - VkPhysicalDeviceProvokingVertexFeaturesEXT physicalDeviceProvokingVertexFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, nullptr }; - VkPhysicalDeviceDescriptorBufferFeaturesEXT physicalDeviceDescriptorBufferFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT, nullptr }; - VkPhysicalDeviceShaderIntegerDotProductFeatures physicalDeviceShaderIntegerDotProductFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, nullptr }; - VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR physicalDeviceFragmentShaderBarycentricFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, nullptr }; - VkPhysicalDeviceRayTracingMotionBlurFeaturesNV physicalDeviceRayTracingMotionBlurFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV, nullptr }; - VkPhysicalDeviceRayTracingValidationFeaturesNV physicalDeviceRayTracingValidationFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV, nullptr }; - VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT physicalDeviceRGBA10X6FormatsFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT, nullptr }; - VkPhysicalDeviceDynamicRenderingFeatures physicalDeviceDynamicRenderingFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, nullptr }; - VkPhysicalDeviceImageViewMinLodFeaturesEXT physicalDeviceImageViewMinLodFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT, nullptr }; - VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT, nullptr }; - VkPhysicalDeviceLinearColorAttachmentFeaturesNV physicalDeviceLinearColorAttachmentFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV, nullptr }; - VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT physicalDeviceGraphicsPipelineLibraryFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT, nullptr }; - VkPhysicalDevicePipelineBinaryFeaturesKHR physicalDevicePipelineBinaryFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR, nullptr }; - VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE physicalDeviceDescriptorSetHostMappingFeaturesVALVE{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE, nullptr }; - VkPhysicalDeviceNestedCommandBufferFeaturesEXT physicalDeviceNestedCommandBufferFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT, nullptr }; - VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT physicalDeviceShaderModuleIdentifierFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT, nullptr }; - VkPhysicalDeviceImageCompressionControlFeaturesEXT physicalDeviceImageCompressionControlFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT, nullptr }; - VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT physicalDeviceImageCompressionControlSwapchainFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT, nullptr }; - VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT physicalDeviceSubpassMergeFeedbackFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT, nullptr }; - VkPhysicalDeviceOpacityMicromapFeaturesEXT physicalDeviceOpacityMicromapFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT, nullptr }; + VkPhysicalDevice4444FormatsFeaturesEXT physicalDevice4444FormatsFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT, nullptr}; + VkPhysicalDeviceSubpassShadingFeaturesHUAWEI physicalDeviceSubpassShadingFeaturesHUAWEI{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI, nullptr}; + VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI physicalDeviceClusterCullingShaderFeaturesHUAWEI{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI, nullptr}; + VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT physicalDeviceShaderImageAtomicInt64FeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT, nullptr}; + VkPhysicalDeviceFragmentShadingRateFeaturesKHR physicalDeviceFragmentShadingRateFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR, nullptr}; + VkPhysicalDeviceShaderTerminateInvocationFeatures physicalDeviceShaderTerminateInvocationFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, nullptr}; + VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV physicalDeviceFragmentShadingRateEnumsFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV, nullptr}; + VkPhysicalDeviceImage2DViewOf3DFeaturesEXT physicalDeviceImage2DViewOf3DFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, nullptr}; + VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT physicalDeviceImageSlicedViewOf3DFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT, nullptr}; + VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT, nullptr}; + VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT physicalDeviceLegacyVertexAttributesFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT, nullptr}; + VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT physicalDeviceMutableDescriptorTypeFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, nullptr}; + VkPhysicalDeviceDepthClipControlFeaturesEXT physicalDeviceDepthClipControlFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT, nullptr}; + VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT physicalDeviceZeroInitializeDeviceMemoryFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT, nullptr}; + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT physicalDeviceDeviceGeneratedCommandsFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT, nullptr}; + VkPhysicalDeviceDepthClampControlFeaturesEXT physicalDeviceDepthClampControlFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT, nullptr}; + VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT physicalDeviceVertexInputDynamicStateFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT, nullptr}; + VkPhysicalDeviceExternalMemoryRDMAFeaturesNV physicalDeviceExternalMemoryRDMAFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV, nullptr}; + VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR, nullptr}; + VkPhysicalDeviceColorWriteEnableFeaturesEXT physicalDeviceColorWriteEnableFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT, nullptr}; + VkPhysicalDeviceSynchronization2Features physicalDeviceSynchronization2Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES, nullptr}; + VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR physicalDeviceUnifiedImageLayoutsFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR, nullptr}; + VkPhysicalDeviceHostImageCopyFeatures physicalDeviceHostImageCopyFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES, nullptr}; + VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT physicalDevicePrimitivesGeneratedQueryFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, nullptr}; + VkPhysicalDeviceLegacyDitheringFeaturesEXT physicalDeviceLegacyDitheringFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT, nullptr}; + VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT, nullptr}; + VkPhysicalDevicePipelineProtectedAccessFeatures physicalDevicePipelineProtectedAccessFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES, nullptr}; + VkPhysicalDeviceVideoMaintenance1FeaturesKHR physicalDeviceVideoMaintenance1FeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR, nullptr}; + VkPhysicalDeviceVideoMaintenance2FeaturesKHR physicalDeviceVideoMaintenance2FeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR, nullptr}; + VkPhysicalDeviceVideoDecodeVP9FeaturesKHR physicalDeviceVideoDecodeVP9FeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR, nullptr}; + VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR physicalDeviceVideoEncodeQuantizationMapFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR, nullptr}; + VkPhysicalDeviceVideoEncodeAV1FeaturesKHR physicalDeviceVideoEncodeAV1FeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR, nullptr}; + VkPhysicalDeviceInheritedViewportScissorFeaturesNV physicalDeviceInheritedViewportScissorFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV, nullptr}; + VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT physicalDeviceYcbcr2Plane444FormatsFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT, nullptr}; + VkPhysicalDeviceProvokingVertexFeaturesEXT physicalDeviceProvokingVertexFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, nullptr}; + VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR physicalDeviceVideoEncodeIntraRefreshFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR, nullptr}; + VkPhysicalDeviceDescriptorBufferFeaturesEXT physicalDeviceDescriptorBufferFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT, nullptr}; + VkPhysicalDeviceShaderIntegerDotProductFeatures physicalDeviceShaderIntegerDotProductFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, nullptr}; + VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR physicalDeviceFragmentShaderBarycentricFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, nullptr}; + VkPhysicalDeviceRayTracingMotionBlurFeaturesNV physicalDeviceRayTracingMotionBlurFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV, nullptr}; + VkPhysicalDeviceRayTracingValidationFeaturesNV physicalDeviceRayTracingValidationFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV, nullptr}; + VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV physicalDeviceRayTracingLinearSweptSpheresFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV, nullptr}; + VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT physicalDeviceRGBA10X6FormatsFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT, nullptr}; + VkPhysicalDeviceDynamicRenderingFeatures physicalDeviceDynamicRenderingFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, nullptr}; + VkPhysicalDeviceImageViewMinLodFeaturesEXT physicalDeviceImageViewMinLodFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT, nullptr}; + VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT, nullptr}; + VkPhysicalDeviceLinearColorAttachmentFeaturesNV physicalDeviceLinearColorAttachmentFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV, nullptr}; + VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT physicalDeviceGraphicsPipelineLibraryFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT, nullptr}; + VkPhysicalDevicePipelineBinaryFeaturesKHR physicalDevicePipelineBinaryFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR, nullptr}; + VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE physicalDeviceDescriptorSetHostMappingFeaturesVALVE{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE, nullptr}; + VkPhysicalDeviceNestedCommandBufferFeaturesEXT physicalDeviceNestedCommandBufferFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT, nullptr}; + VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT physicalDeviceShaderModuleIdentifierFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT, nullptr}; + VkPhysicalDeviceImageCompressionControlFeaturesEXT physicalDeviceImageCompressionControlFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT, nullptr}; + VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT physicalDeviceImageCompressionControlSwapchainFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT, nullptr}; + VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT physicalDeviceSubpassMergeFeedbackFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT, nullptr}; + VkPhysicalDeviceOpacityMicromapFeaturesEXT physicalDeviceOpacityMicromapFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT, nullptr}; #ifdef VK_ENABLE_BETA_EXTENSIONS - VkPhysicalDeviceDisplacementMicromapFeaturesNV physicalDeviceDisplacementMicromapFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV, nullptr }; + VkPhysicalDeviceDisplacementMicromapFeaturesNV physicalDeviceDisplacementMicromapFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV, nullptr}; #endif - VkPhysicalDevicePipelinePropertiesFeaturesEXT physicalDevicePipelinePropertiesFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT, nullptr }; - VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD, nullptr }; - VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT physicalDeviceNonSeamlessCubeMapFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT, nullptr }; - VkPhysicalDevicePipelineRobustnessFeaturesEXT physicalDevicePipelineRobustnessFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT, nullptr }; - VkPhysicalDeviceImageProcessingFeaturesQCOM physicalDeviceImageProcessingFeaturesQCOM{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM, nullptr }; - VkPhysicalDeviceTilePropertiesFeaturesQCOM physicalDeviceTilePropertiesFeaturesQCOM{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM, nullptr }; - VkPhysicalDeviceAmigoProfilingFeaturesSEC physicalDeviceAmigoProfilingFeaturesSEC{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC, nullptr }; - VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT, nullptr }; - VkPhysicalDeviceDepthClampZeroOneFeaturesEXT physicalDeviceDepthClampZeroOneFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT, nullptr }; - VkPhysicalDeviceAddressBindingReportFeaturesEXT physicalDeviceAddressBindingReportFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT, nullptr }; - VkPhysicalDeviceOpticalFlowFeaturesNV physicalDeviceOpticalFlowFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV, nullptr }; - VkPhysicalDeviceFaultFeaturesEXT physicalDeviceFaultFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT, nullptr }; - VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT physicalDevicePipelineLibraryGroupHandlesFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT, nullptr }; - VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM physicalDeviceShaderCoreBuiltinsFeaturesARM{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM, nullptr }; - VkPhysicalDeviceFrameBoundaryFeaturesEXT physicalDeviceFrameBoundaryFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT, nullptr }; - VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT, nullptr }; - VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT physicalDeviceSwapchainMaintenance1FeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT, nullptr }; - VkPhysicalDeviceDepthBiasControlFeaturesEXT physicalDeviceDepthBiasControlFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT, nullptr }; - VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV physicalDeviceRayTracingInvocationReorderFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV, nullptr }; - VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV physicalDeviceExtendedSparseAddressSpaceFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV, nullptr }; - VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM physicalDeviceMultiviewPerViewViewportsFeaturesQCOM{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM, nullptr }; - VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR physicalDeviceRayTracingPositionFetchFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR, nullptr }; - VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM, nullptr }; - VkPhysicalDeviceShaderObjectFeaturesEXT physicalDeviceShaderObjectFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT, nullptr }; - VkPhysicalDeviceShaderTileImageFeaturesEXT physicalDeviceShaderTileImageFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT, nullptr }; + VkPhysicalDevicePipelinePropertiesFeaturesEXT physicalDevicePipelinePropertiesFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT, nullptr}; + VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD, nullptr}; + VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT physicalDeviceNonSeamlessCubeMapFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT, nullptr}; + VkPhysicalDevicePipelineRobustnessFeatures physicalDevicePipelineRobustnessFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES, nullptr}; + VkPhysicalDeviceImageProcessingFeaturesQCOM physicalDeviceImageProcessingFeaturesQCOM{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM, nullptr}; + VkPhysicalDeviceTilePropertiesFeaturesQCOM physicalDeviceTilePropertiesFeaturesQCOM{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM, nullptr}; + VkPhysicalDeviceAmigoProfilingFeaturesSEC physicalDeviceAmigoProfilingFeaturesSEC{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC, nullptr}; + VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT, nullptr}; + VkPhysicalDeviceAddressBindingReportFeaturesEXT physicalDeviceAddressBindingReportFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT, nullptr}; + VkPhysicalDeviceOpticalFlowFeaturesNV physicalDeviceOpticalFlowFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV, nullptr}; + VkPhysicalDeviceFaultFeaturesEXT physicalDeviceFaultFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT, nullptr}; + VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT physicalDevicePipelineLibraryGroupHandlesFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT, nullptr}; + VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM physicalDeviceShaderCoreBuiltinsFeaturesARM{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM, nullptr}; + VkPhysicalDeviceFrameBoundaryFeaturesEXT physicalDeviceFrameBoundaryFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT, nullptr}; + VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT, nullptr}; + VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR physicalDeviceSwapchainMaintenance1FeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR, nullptr}; + VkPhysicalDeviceDepthBiasControlFeaturesEXT physicalDeviceDepthBiasControlFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT, nullptr}; + VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV physicalDeviceRayTracingInvocationReorderFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV, nullptr}; + VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV physicalDeviceExtendedSparseAddressSpaceFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV, nullptr}; + VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM physicalDeviceMultiviewPerViewViewportsFeaturesQCOM{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM, nullptr}; + VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR physicalDeviceRayTracingPositionFetchFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR, nullptr}; + VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM, nullptr}; + VkPhysicalDeviceShaderObjectFeaturesEXT physicalDeviceShaderObjectFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT, nullptr}; + VkPhysicalDeviceShaderTileImageFeaturesEXT physicalDeviceShaderTileImageFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT, nullptr}; #ifdef VK_USE_PLATFORM_SCREEN_QNX - VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX physicalDeviceExternalMemoryScreenBufferFeaturesQNX{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX, nullptr }; + VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX physicalDeviceExternalMemoryScreenBufferFeaturesQNX{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX, nullptr}; #endif - VkPhysicalDeviceCooperativeMatrixFeaturesKHR physicalDeviceCooperativeMatrixFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR, nullptr }; + VkPhysicalDeviceCooperativeMatrixFeaturesKHR physicalDeviceCooperativeMatrixFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR, nullptr}; #ifdef VK_ENABLE_BETA_EXTENSIONS - VkPhysicalDeviceShaderEnqueueFeaturesAMDX physicalDeviceShaderEnqueueFeaturesAMDX{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX, nullptr }; + VkPhysicalDeviceShaderEnqueueFeaturesAMDX physicalDeviceShaderEnqueueFeaturesAMDX{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX, nullptr}; #endif - VkPhysicalDeviceAntiLagFeaturesAMD physicalDeviceAntiLagFeaturesAMD{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD, nullptr }; - VkPhysicalDeviceCubicClampFeaturesQCOM physicalDeviceCubicClampFeaturesQCOM{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM, nullptr }; - VkPhysicalDeviceYcbcrDegammaFeaturesQCOM physicalDeviceYcbcrDegammaFeaturesQCOM{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM, nullptr }; - VkPhysicalDeviceCubicWeightsFeaturesQCOM physicalDeviceCubicWeightsFeaturesQCOM{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM, nullptr }; - VkPhysicalDeviceImageProcessing2FeaturesQCOM physicalDeviceImageProcessing2FeaturesQCOM{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM, nullptr }; - VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV physicalDeviceDescriptorPoolOverallocationFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV, nullptr }; - VkPhysicalDevicePerStageDescriptorSetFeaturesNV physicalDevicePerStageDescriptorSetFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV, nullptr }; + VkPhysicalDeviceAntiLagFeaturesAMD physicalDeviceAntiLagFeaturesAMD{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD, nullptr}; + VkPhysicalDeviceTileMemoryHeapFeaturesQCOM physicalDeviceTileMemoryHeapFeaturesQCOM{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM, nullptr}; + VkPhysicalDeviceCubicClampFeaturesQCOM physicalDeviceCubicClampFeaturesQCOM{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM, nullptr}; + VkPhysicalDeviceYcbcrDegammaFeaturesQCOM physicalDeviceYcbcrDegammaFeaturesQCOM{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM, nullptr}; + VkPhysicalDeviceCubicWeightsFeaturesQCOM physicalDeviceCubicWeightsFeaturesQCOM{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM, nullptr}; + VkPhysicalDeviceImageProcessing2FeaturesQCOM physicalDeviceImageProcessing2FeaturesQCOM{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM, nullptr}; + VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV physicalDeviceDescriptorPoolOverallocationFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV, nullptr}; + VkPhysicalDevicePerStageDescriptorSetFeaturesNV physicalDevicePerStageDescriptorSetFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV, nullptr}; #ifdef VK_USE_PLATFORM_ANDROID_KHR - VkPhysicalDeviceExternalFormatResolveFeaturesANDROID physicalDeviceExternalFormatResolveFeaturesANDROID{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID, nullptr }; + VkPhysicalDeviceExternalFormatResolveFeaturesANDROID physicalDeviceExternalFormatResolveFeaturesANDROID{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID, nullptr}; +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VkPhysicalDeviceCudaKernelLaunchFeaturesNV physicalDeviceCudaKernelLaunchFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV, nullptr}; +#endif + VkPhysicalDeviceSchedulingControlsFeaturesARM physicalDeviceSchedulingControlsFeaturesARM{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM, nullptr}; + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG physicalDeviceRelaxedLineRasterizationFeaturesIMG{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, nullptr}; + VkPhysicalDeviceRenderPassStripedFeaturesARM physicalDeviceRenderPassStripedFeaturesARM{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM, nullptr}; + VkPhysicalDevicePipelineOpacityMicromapFeaturesARM physicalDevicePipelineOpacityMicromapFeaturesARM{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM, nullptr}; + VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR physicalDeviceShaderMaximalReconvergenceFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR, nullptr}; + VkPhysicalDeviceShaderSubgroupRotateFeatures physicalDeviceShaderSubgroupRotateFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES, nullptr}; + VkPhysicalDeviceShaderExpectAssumeFeatures physicalDeviceShaderExpectAssumeFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES, nullptr}; + VkPhysicalDeviceShaderFloatControls2Features physicalDeviceShaderFloatControls2Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES, nullptr}; + VkPhysicalDeviceDynamicRenderingLocalReadFeatures physicalDeviceDynamicRenderingLocalReadFeatures{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES, nullptr}; + VkPhysicalDeviceShaderQuadControlFeaturesKHR physicalDeviceShaderQuadControlFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR, nullptr}; + VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV physicalDeviceShaderAtomicFloat16VectorFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV, nullptr}; + VkPhysicalDeviceMapMemoryPlacedFeaturesEXT physicalDeviceMapMemoryPlacedFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT, nullptr}; + VkPhysicalDeviceShaderBfloat16FeaturesKHR physicalDeviceShaderBfloat16FeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR, nullptr}; + VkPhysicalDeviceRawAccessChainsFeaturesNV physicalDeviceRawAccessChainsFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV, nullptr}; + VkPhysicalDeviceCommandBufferInheritanceFeaturesNV physicalDeviceCommandBufferInheritanceFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV, nullptr}; + VkPhysicalDeviceImageAlignmentControlFeaturesMESA physicalDeviceImageAlignmentControlFeaturesMESA{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA, nullptr}; + VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT physicalDeviceShaderReplicatedCompositesFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT, nullptr}; + VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR physicalDevicePresentModeFifoLatestReadyFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR, nullptr}; + VkPhysicalDeviceCooperativeMatrix2FeaturesNV physicalDeviceCooperativeMatrix2FeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV, nullptr}; + VkPhysicalDeviceHdrVividFeaturesHUAWEI physicalDeviceHdrVividFeaturesHUAWEI{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI, nullptr}; + VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT physicalDeviceVertexAttributeRobustnessFeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT, nullptr}; + VkPhysicalDeviceDepthClampZeroOneFeaturesKHR physicalDeviceDepthClampZeroOneFeaturesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR, nullptr}; + VkPhysicalDeviceCooperativeVectorFeaturesNV physicalDeviceCooperativeVectorFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV, nullptr}; + VkPhysicalDeviceTileShadingFeaturesQCOM physicalDeviceTileShadingFeaturesQCOM{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM, nullptr}; + VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE physicalDeviceFragmentDensityMapLayeredFeaturesVALVE{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE, nullptr}; +#ifdef VK_ENABLE_BETA_EXTENSIONS + VkPhysicalDevicePresentMeteringFeaturesNV physicalDevicePresentMeteringFeaturesNV{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV, nullptr}; #endif - VkPhysicalDeviceCudaKernelLaunchFeaturesNV physicalDeviceCudaKernelLaunchFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV, nullptr }; - VkPhysicalDeviceSchedulingControlsFeaturesARM physicalDeviceSchedulingControlsFeaturesARM{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM, nullptr }; - VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG physicalDeviceRelaxedLineRasterizationFeaturesIMG{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, nullptr }; - VkPhysicalDeviceRenderPassStripedFeaturesARM physicalDeviceRenderPassStripedFeaturesARM{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM, nullptr }; - VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR physicalDeviceShaderMaximalReconvergenceFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR, nullptr }; - VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR physicalDeviceShaderSubgroupRotateFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR, nullptr }; - VkPhysicalDeviceShaderExpectAssumeFeaturesKHR physicalDeviceShaderExpectAssumeFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR, nullptr }; - VkPhysicalDeviceShaderFloatControls2FeaturesKHR physicalDeviceShaderFloatControls2FeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR, nullptr }; - VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR physicalDeviceDynamicRenderingLocalReadFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR, nullptr }; - VkPhysicalDeviceShaderQuadControlFeaturesKHR physicalDeviceShaderQuadControlFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR, nullptr }; - VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV physicalDeviceShaderAtomicFloat16VectorFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV, nullptr }; - VkPhysicalDeviceMapMemoryPlacedFeaturesEXT physicalDeviceMapMemoryPlacedFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT, nullptr }; - VkPhysicalDeviceRawAccessChainsFeaturesNV physicalDeviceRawAccessChainsFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV, nullptr }; - VkPhysicalDeviceCommandBufferInheritanceFeaturesNV physicalDeviceCommandBufferInheritanceFeaturesNV{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV, nullptr }; - VkPhysicalDeviceImageAlignmentControlFeaturesMESA physicalDeviceImageAlignmentControlFeaturesMESA{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA, nullptr }; - VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT physicalDeviceShaderReplicatedCompositesFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT, nullptr }; - VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT physicalDevicePresentModeFifoLatestReadyFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT, nullptr }; - VkPhysicalDeviceFeatures2KHR physicalDeviceFeatures2KHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, nullptr }; - - FeaturesChain() { - // Initializing all feature structures, number of Features (VkBool32) per structure. - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR, size() }); + VkPhysicalDeviceFormatPackFeaturesARM physicalDeviceFormatPackFeaturesARM{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM, nullptr}; + VkPhysicalDeviceTensorFeaturesARM physicalDeviceTensorFeaturesARM{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM, nullptr}; + VkPhysicalDeviceDescriptorBufferTensorFeaturesARM physicalDeviceDescriptorBufferTensorFeaturesARM{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM, nullptr}; + VkPhysicalDeviceShaderFloat8FeaturesEXT physicalDeviceShaderFloat8FeaturesEXT{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT, nullptr}; + VkPhysicalDeviceDataGraphFeaturesARM physicalDeviceDataGraphFeaturesARM{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM, nullptr}; + VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC physicalDevicePipelineCacheIncrementalModeFeaturesSEC{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC, nullptr}; + VkPhysicalDeviceFeatures2KHR physicalDeviceFeatures2KHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, nullptr}; + + FeaturesChain() + { + // Initializing all feature structures, number of Features (VkBool32) per structure. + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR, size()}); #ifdef VK_ENABLE_BETA_EXTENSIONS - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR, size() }); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR, size()}); #endif - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT, size() }); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT, size()}); #ifdef VK_ENABLE_BETA_EXTENSIONS - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV, size() }); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV, size()}); #endif - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT, size() }); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT, size()}); #ifdef VK_USE_PLATFORM_SCREEN_QNX - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX, size() }); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX, size()}); #endif - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR, size() }); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR, size()}); #ifdef VK_ENABLE_BETA_EXTENSIONS - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX, size() }); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX, size()}); #endif - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV, size() }); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV, size()}); #ifdef VK_USE_PLATFORM_ANDROID_KHR - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID, size() }); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID, size()}); +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV, size()}); +#endif + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE, size()}); +#ifdef VK_ENABLE_BETA_EXTENSIONS + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV, size()}); #endif - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT, size() }); - this->structureSize.insert({ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, size() }); - - //Initializing the full list of available structure features - void* pNext = nullptr; - physicalDeviceDeviceGeneratedCommandsFeaturesNV.pNext = pNext; - pNext = &physicalDeviceDeviceGeneratedCommandsFeaturesNV; - physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.pNext = pNext; - pNext = &physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; - physicalDevicePrivateDataFeatures.pNext = pNext; - pNext = &physicalDevicePrivateDataFeatures; - physicalDeviceVariablePointersFeatures.pNext = pNext; - pNext = &physicalDeviceVariablePointersFeatures; - physicalDeviceMultiviewFeatures.pNext = pNext; - pNext = &physicalDeviceMultiviewFeatures; - physicalDevicePresentIdFeaturesKHR.pNext = pNext; - pNext = &physicalDevicePresentIdFeaturesKHR; - physicalDevicePresentWaitFeaturesKHR.pNext = pNext; - pNext = &physicalDevicePresentWaitFeaturesKHR; - physicalDevice16BitStorageFeatures.pNext = pNext; - pNext = &physicalDevice16BitStorageFeatures; - physicalDeviceShaderSubgroupExtendedTypesFeatures.pNext = pNext; - pNext = &physicalDeviceShaderSubgroupExtendedTypesFeatures; - physicalDeviceSamplerYcbcrConversionFeatures.pNext = pNext; - pNext = &physicalDeviceSamplerYcbcrConversionFeatures; - physicalDeviceProtectedMemoryFeatures.pNext = pNext; - pNext = &physicalDeviceProtectedMemoryFeatures; - physicalDeviceBlendOperationAdvancedFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceBlendOperationAdvancedFeaturesEXT; - physicalDeviceMultiDrawFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceMultiDrawFeaturesEXT; - physicalDeviceInlineUniformBlockFeatures.pNext = pNext; - pNext = &physicalDeviceInlineUniformBlockFeatures; - physicalDeviceMaintenance4Features.pNext = pNext; - pNext = &physicalDeviceMaintenance4Features; - physicalDeviceMaintenance5FeaturesKHR.pNext = pNext; - pNext = &physicalDeviceMaintenance5FeaturesKHR; - physicalDeviceMaintenance6FeaturesKHR.pNext = pNext; - pNext = &physicalDeviceMaintenance6FeaturesKHR; - physicalDeviceMaintenance7FeaturesKHR.pNext = pNext; - pNext = &physicalDeviceMaintenance7FeaturesKHR; - physicalDeviceShaderDrawParametersFeatures.pNext = pNext; - pNext = &physicalDeviceShaderDrawParametersFeatures; - physicalDeviceShaderFloat16Int8Features.pNext = pNext; - pNext = &physicalDeviceShaderFloat16Int8Features; - physicalDeviceHostQueryResetFeatures.pNext = pNext; - pNext = &physicalDeviceHostQueryResetFeatures; - physicalDeviceGlobalPriorityQueryFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceGlobalPriorityQueryFeaturesKHR; - physicalDeviceDeviceMemoryReportFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceDeviceMemoryReportFeaturesEXT; - physicalDeviceDescriptorIndexingFeatures.pNext = pNext; - pNext = &physicalDeviceDescriptorIndexingFeatures; - physicalDeviceTimelineSemaphoreFeatures.pNext = pNext; - pNext = &physicalDeviceTimelineSemaphoreFeatures; - physicalDevice8BitStorageFeatures.pNext = pNext; - pNext = &physicalDevice8BitStorageFeatures; - physicalDeviceConditionalRenderingFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceConditionalRenderingFeaturesEXT; - physicalDeviceVulkanMemoryModelFeatures.pNext = pNext; - pNext = &physicalDeviceVulkanMemoryModelFeatures; - physicalDeviceShaderAtomicInt64Features.pNext = pNext; - pNext = &physicalDeviceShaderAtomicInt64Features; - physicalDeviceShaderAtomicFloatFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceShaderAtomicFloatFeaturesEXT; - physicalDeviceShaderAtomicFloat2FeaturesEXT.pNext = pNext; - pNext = &physicalDeviceShaderAtomicFloat2FeaturesEXT; - physicalDeviceVertexAttributeDivisorFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceVertexAttributeDivisorFeaturesKHR; - physicalDeviceASTCDecodeFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceASTCDecodeFeaturesEXT; - physicalDeviceTransformFeedbackFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceTransformFeedbackFeaturesEXT; - physicalDeviceRepresentativeFragmentTestFeaturesNV.pNext = pNext; - pNext = &physicalDeviceRepresentativeFragmentTestFeaturesNV; - physicalDeviceExclusiveScissorFeaturesNV.pNext = pNext; - pNext = &physicalDeviceExclusiveScissorFeaturesNV; - physicalDeviceCornerSampledImageFeaturesNV.pNext = pNext; - pNext = &physicalDeviceCornerSampledImageFeaturesNV; - physicalDeviceComputeShaderDerivativesFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceComputeShaderDerivativesFeaturesKHR; - physicalDeviceShaderImageFootprintFeaturesNV.pNext = pNext; - pNext = &physicalDeviceShaderImageFootprintFeaturesNV; - physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.pNext = pNext; - pNext = &physicalDeviceDedicatedAllocationImageAliasingFeaturesNV; - physicalDeviceCopyMemoryIndirectFeaturesNV.pNext = pNext; - pNext = &physicalDeviceCopyMemoryIndirectFeaturesNV; - physicalDeviceMemoryDecompressionFeaturesNV.pNext = pNext; - pNext = &physicalDeviceMemoryDecompressionFeaturesNV; - physicalDeviceShadingRateImageFeaturesNV.pNext = pNext; - pNext = &physicalDeviceShadingRateImageFeaturesNV; - physicalDeviceInvocationMaskFeaturesHUAWEI.pNext = pNext; - pNext = &physicalDeviceInvocationMaskFeaturesHUAWEI; - physicalDeviceMeshShaderFeaturesNV.pNext = pNext; - pNext = &physicalDeviceMeshShaderFeaturesNV; - physicalDeviceMeshShaderFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceMeshShaderFeaturesEXT; - physicalDeviceAccelerationStructureFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceAccelerationStructureFeaturesKHR; - physicalDeviceRayTracingPipelineFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceRayTracingPipelineFeaturesKHR; - physicalDeviceRayQueryFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceRayQueryFeaturesKHR; - physicalDeviceRayTracingMaintenance1FeaturesKHR.pNext = pNext; - pNext = &physicalDeviceRayTracingMaintenance1FeaturesKHR; - physicalDeviceFragmentDensityMapFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceFragmentDensityMapFeaturesEXT; - physicalDeviceFragmentDensityMap2FeaturesEXT.pNext = pNext; - pNext = &physicalDeviceFragmentDensityMap2FeaturesEXT; - physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.pNext = pNext; - pNext = &physicalDeviceFragmentDensityMapOffsetFeaturesQCOM; - physicalDeviceScalarBlockLayoutFeatures.pNext = pNext; - pNext = &physicalDeviceScalarBlockLayoutFeatures; - physicalDeviceUniformBufferStandardLayoutFeatures.pNext = pNext; - pNext = &physicalDeviceUniformBufferStandardLayoutFeatures; - physicalDeviceDepthClipEnableFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceDepthClipEnableFeaturesEXT; - physicalDeviceMemoryPriorityFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceMemoryPriorityFeaturesEXT; - physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pNext = pNext; - pNext = &physicalDevicePageableDeviceLocalMemoryFeaturesEXT; - physicalDeviceBufferDeviceAddressFeatures.pNext = pNext; - pNext = &physicalDeviceBufferDeviceAddressFeatures; - physicalDeviceBufferDeviceAddressFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceBufferDeviceAddressFeaturesEXT; - physicalDeviceImagelessFramebufferFeatures.pNext = pNext; - pNext = &physicalDeviceImagelessFramebufferFeatures; - physicalDeviceTextureCompressionASTCHDRFeatures.pNext = pNext; - pNext = &physicalDeviceTextureCompressionASTCHDRFeatures; - physicalDeviceCooperativeMatrixFeaturesNV.pNext = pNext; - pNext = &physicalDeviceCooperativeMatrixFeaturesNV; - physicalDeviceYcbcrImageArraysFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceYcbcrImageArraysFeaturesEXT; - physicalDevicePresentBarrierFeaturesNV.pNext = pNext; - pNext = &physicalDevicePresentBarrierFeaturesNV; - physicalDevicePerformanceQueryFeaturesKHR.pNext = pNext; - pNext = &physicalDevicePerformanceQueryFeaturesKHR; - physicalDeviceCoverageReductionModeFeaturesNV.pNext = pNext; - pNext = &physicalDeviceCoverageReductionModeFeaturesNV; - physicalDeviceShaderIntegerFunctions2FeaturesINTEL.pNext = pNext; - pNext = &physicalDeviceShaderIntegerFunctions2FeaturesINTEL; - physicalDeviceShaderClockFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceShaderClockFeaturesKHR; - physicalDeviceIndexTypeUint8FeaturesKHR.pNext = pNext; - pNext = &physicalDeviceIndexTypeUint8FeaturesKHR; - physicalDeviceShaderSMBuiltinsFeaturesNV.pNext = pNext; - pNext = &physicalDeviceShaderSMBuiltinsFeaturesNV; - physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceFragmentShaderInterlockFeaturesEXT; - physicalDeviceSeparateDepthStencilLayoutsFeatures.pNext = pNext; - pNext = &physicalDeviceSeparateDepthStencilLayoutsFeatures; - physicalDevicePrimitiveTopologyListRestartFeaturesEXT.pNext = pNext; - pNext = &physicalDevicePrimitiveTopologyListRestartFeaturesEXT; - physicalDevicePipelineExecutablePropertiesFeaturesKHR.pNext = pNext; - pNext = &physicalDevicePipelineExecutablePropertiesFeaturesKHR; - physicalDeviceShaderDemoteToHelperInvocationFeatures.pNext = pNext; - pNext = &physicalDeviceShaderDemoteToHelperInvocationFeatures; - physicalDeviceTexelBufferAlignmentFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceTexelBufferAlignmentFeaturesEXT; - physicalDeviceSubgroupSizeControlFeatures.pNext = pNext; - pNext = &physicalDeviceSubgroupSizeControlFeatures; - physicalDeviceLineRasterizationFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceLineRasterizationFeaturesKHR; - physicalDevicePipelineCreationCacheControlFeatures.pNext = pNext; - pNext = &physicalDevicePipelineCreationCacheControlFeatures; - physicalDeviceVulkan11Features.pNext = pNext; - pNext = &physicalDeviceVulkan11Features; - physicalDeviceVulkan12Features.pNext = pNext; - pNext = &physicalDeviceVulkan12Features; - physicalDeviceVulkan13Features.pNext = pNext; - pNext = &physicalDeviceVulkan13Features; - physicalDeviceCoherentMemoryFeaturesAMD.pNext = pNext; - pNext = &physicalDeviceCoherentMemoryFeaturesAMD; - physicalDeviceCustomBorderColorFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceCustomBorderColorFeaturesEXT; - physicalDeviceBorderColorSwizzleFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceBorderColorSwizzleFeaturesEXT; - physicalDeviceExtendedDynamicStateFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceExtendedDynamicStateFeaturesEXT; - physicalDeviceExtendedDynamicState2FeaturesEXT.pNext = pNext; - pNext = &physicalDeviceExtendedDynamicState2FeaturesEXT; - physicalDeviceExtendedDynamicState3FeaturesEXT.pNext = pNext; - pNext = &physicalDeviceExtendedDynamicState3FeaturesEXT; - physicalDeviceDiagnosticsConfigFeaturesNV.pNext = pNext; - pNext = &physicalDeviceDiagnosticsConfigFeaturesNV; - physicalDeviceZeroInitializeWorkgroupMemoryFeatures.pNext = pNext; - pNext = &physicalDeviceZeroInitializeWorkgroupMemoryFeatures; - physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; - physicalDeviceRobustness2FeaturesEXT.pNext = pNext; - pNext = &physicalDeviceRobustness2FeaturesEXT; - physicalDeviceImageRobustnessFeatures.pNext = pNext; - pNext = &physicalDeviceImageRobustnessFeatures; - physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC, size()}); + this->structureSize.insert({VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, size()}); + + // Initializing the full list of available structure features + void *pNext = nullptr; + physicalDeviceDeviceGeneratedCommandsFeaturesNV.pNext = pNext; + pNext = &physicalDeviceDeviceGeneratedCommandsFeaturesNV; + physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.pNext = pNext; + pNext = &physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; + physicalDevicePrivateDataFeatures.pNext = pNext; + pNext = &physicalDevicePrivateDataFeatures; + physicalDeviceClusterAccelerationStructureFeaturesNV.pNext = pNext; + pNext = &physicalDeviceClusterAccelerationStructureFeaturesNV; + physicalDeviceVariablePointersFeatures.pNext = pNext; + pNext = &physicalDeviceVariablePointersFeatures; + physicalDeviceMultiviewFeatures.pNext = pNext; + pNext = &physicalDeviceMultiviewFeatures; + physicalDevicePresentIdFeaturesKHR.pNext = pNext; + pNext = &physicalDevicePresentIdFeaturesKHR; + physicalDevicePresentId2FeaturesKHR.pNext = pNext; + pNext = &physicalDevicePresentId2FeaturesKHR; + physicalDevicePresentWaitFeaturesKHR.pNext = pNext; + pNext = &physicalDevicePresentWaitFeaturesKHR; + physicalDevicePresentWait2FeaturesKHR.pNext = pNext; + pNext = &physicalDevicePresentWait2FeaturesKHR; + physicalDevice16BitStorageFeatures.pNext = pNext; + pNext = &physicalDevice16BitStorageFeatures; + physicalDeviceShaderSubgroupExtendedTypesFeatures.pNext = pNext; + pNext = &physicalDeviceShaderSubgroupExtendedTypesFeatures; + physicalDeviceSamplerYcbcrConversionFeatures.pNext = pNext; + pNext = &physicalDeviceSamplerYcbcrConversionFeatures; + physicalDeviceProtectedMemoryFeatures.pNext = pNext; + pNext = &physicalDeviceProtectedMemoryFeatures; + physicalDeviceBlendOperationAdvancedFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceBlendOperationAdvancedFeaturesEXT; + physicalDeviceMultiDrawFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceMultiDrawFeaturesEXT; + physicalDeviceInlineUniformBlockFeatures.pNext = pNext; + pNext = &physicalDeviceInlineUniformBlockFeatures; + physicalDeviceMaintenance4Features.pNext = pNext; + pNext = &physicalDeviceMaintenance4Features; + physicalDeviceMaintenance5Features.pNext = pNext; + pNext = &physicalDeviceMaintenance5Features; + physicalDeviceMaintenance6Features.pNext = pNext; + pNext = &physicalDeviceMaintenance6Features; + physicalDeviceMaintenance7FeaturesKHR.pNext = pNext; + pNext = &physicalDeviceMaintenance7FeaturesKHR; + physicalDeviceMaintenance8FeaturesKHR.pNext = pNext; + pNext = &physicalDeviceMaintenance8FeaturesKHR; + physicalDeviceMaintenance9FeaturesKHR.pNext = pNext; + pNext = &physicalDeviceMaintenance9FeaturesKHR; + physicalDeviceShaderDrawParametersFeatures.pNext = pNext; + pNext = &physicalDeviceShaderDrawParametersFeatures; + physicalDeviceShaderFloat16Int8Features.pNext = pNext; + pNext = &physicalDeviceShaderFloat16Int8Features; + physicalDeviceHostQueryResetFeatures.pNext = pNext; + pNext = &physicalDeviceHostQueryResetFeatures; + physicalDeviceGlobalPriorityQueryFeatures.pNext = pNext; + pNext = &physicalDeviceGlobalPriorityQueryFeatures; + physicalDeviceDeviceMemoryReportFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceDeviceMemoryReportFeaturesEXT; + physicalDeviceDescriptorIndexingFeatures.pNext = pNext; + pNext = &physicalDeviceDescriptorIndexingFeatures; + physicalDeviceTimelineSemaphoreFeatures.pNext = pNext; + pNext = &physicalDeviceTimelineSemaphoreFeatures; + physicalDevice8BitStorageFeatures.pNext = pNext; + pNext = &physicalDevice8BitStorageFeatures; + physicalDeviceConditionalRenderingFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceConditionalRenderingFeaturesEXT; + physicalDeviceVulkanMemoryModelFeatures.pNext = pNext; + pNext = &physicalDeviceVulkanMemoryModelFeatures; + physicalDeviceShaderAtomicInt64Features.pNext = pNext; + pNext = &physicalDeviceShaderAtomicInt64Features; + physicalDeviceShaderAtomicFloatFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceShaderAtomicFloatFeaturesEXT; + physicalDeviceShaderAtomicFloat2FeaturesEXT.pNext = pNext; + pNext = &physicalDeviceShaderAtomicFloat2FeaturesEXT; + physicalDeviceVertexAttributeDivisorFeatures.pNext = pNext; + pNext = &physicalDeviceVertexAttributeDivisorFeatures; + physicalDeviceASTCDecodeFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceASTCDecodeFeaturesEXT; + physicalDeviceTransformFeedbackFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceTransformFeedbackFeaturesEXT; + physicalDeviceRepresentativeFragmentTestFeaturesNV.pNext = pNext; + pNext = &physicalDeviceRepresentativeFragmentTestFeaturesNV; + physicalDeviceExclusiveScissorFeaturesNV.pNext = pNext; + pNext = &physicalDeviceExclusiveScissorFeaturesNV; + physicalDeviceCornerSampledImageFeaturesNV.pNext = pNext; + pNext = &physicalDeviceCornerSampledImageFeaturesNV; + physicalDeviceComputeShaderDerivativesFeaturesKHR.pNext = pNext; + pNext = &physicalDeviceComputeShaderDerivativesFeaturesKHR; + physicalDeviceShaderImageFootprintFeaturesNV.pNext = pNext; + pNext = &physicalDeviceShaderImageFootprintFeaturesNV; + physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.pNext = pNext; + pNext = &physicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + physicalDeviceCopyMemoryIndirectFeaturesNV.pNext = pNext; + pNext = &physicalDeviceCopyMemoryIndirectFeaturesNV; + physicalDeviceMemoryDecompressionFeaturesNV.pNext = pNext; + pNext = &physicalDeviceMemoryDecompressionFeaturesNV; + physicalDeviceShadingRateImageFeaturesNV.pNext = pNext; + pNext = &physicalDeviceShadingRateImageFeaturesNV; + physicalDeviceInvocationMaskFeaturesHUAWEI.pNext = pNext; + pNext = &physicalDeviceInvocationMaskFeaturesHUAWEI; + physicalDeviceMeshShaderFeaturesNV.pNext = pNext; + pNext = &physicalDeviceMeshShaderFeaturesNV; + physicalDeviceMeshShaderFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceMeshShaderFeaturesEXT; + physicalDeviceAccelerationStructureFeaturesKHR.pNext = pNext; + pNext = &physicalDeviceAccelerationStructureFeaturesKHR; + physicalDeviceRayTracingPipelineFeaturesKHR.pNext = pNext; + pNext = &physicalDeviceRayTracingPipelineFeaturesKHR; + physicalDeviceRayQueryFeaturesKHR.pNext = pNext; + pNext = &physicalDeviceRayQueryFeaturesKHR; + physicalDeviceRayTracingMaintenance1FeaturesKHR.pNext = pNext; + pNext = &physicalDeviceRayTracingMaintenance1FeaturesKHR; + physicalDeviceFragmentDensityMapFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceFragmentDensityMapFeaturesEXT; + physicalDeviceFragmentDensityMap2FeaturesEXT.pNext = pNext; + pNext = &physicalDeviceFragmentDensityMap2FeaturesEXT; + physicalDeviceFragmentDensityMapOffsetFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceFragmentDensityMapOffsetFeaturesEXT; + physicalDeviceScalarBlockLayoutFeatures.pNext = pNext; + pNext = &physicalDeviceScalarBlockLayoutFeatures; + physicalDeviceUniformBufferStandardLayoutFeatures.pNext = pNext; + pNext = &physicalDeviceUniformBufferStandardLayoutFeatures; + physicalDeviceDepthClipEnableFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceDepthClipEnableFeaturesEXT; + physicalDeviceMemoryPriorityFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceMemoryPriorityFeaturesEXT; + physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pNext = pNext; + pNext = &physicalDevicePageableDeviceLocalMemoryFeaturesEXT; + physicalDeviceBufferDeviceAddressFeatures.pNext = pNext; + pNext = &physicalDeviceBufferDeviceAddressFeatures; + physicalDeviceBufferDeviceAddressFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceBufferDeviceAddressFeaturesEXT; + physicalDeviceImagelessFramebufferFeatures.pNext = pNext; + pNext = &physicalDeviceImagelessFramebufferFeatures; + physicalDeviceTextureCompressionASTCHDRFeatures.pNext = pNext; + pNext = &physicalDeviceTextureCompressionASTCHDRFeatures; + physicalDeviceCooperativeMatrixFeaturesNV.pNext = pNext; + pNext = &physicalDeviceCooperativeMatrixFeaturesNV; + physicalDeviceYcbcrImageArraysFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceYcbcrImageArraysFeaturesEXT; + physicalDevicePresentBarrierFeaturesNV.pNext = pNext; + pNext = &physicalDevicePresentBarrierFeaturesNV; + physicalDevicePerformanceQueryFeaturesKHR.pNext = pNext; + pNext = &physicalDevicePerformanceQueryFeaturesKHR; + physicalDeviceCoverageReductionModeFeaturesNV.pNext = pNext; + pNext = &physicalDeviceCoverageReductionModeFeaturesNV; + physicalDeviceShaderIntegerFunctions2FeaturesINTEL.pNext = pNext; + pNext = &physicalDeviceShaderIntegerFunctions2FeaturesINTEL; + physicalDeviceShaderClockFeaturesKHR.pNext = pNext; + pNext = &physicalDeviceShaderClockFeaturesKHR; + physicalDeviceIndexTypeUint8Features.pNext = pNext; + pNext = &physicalDeviceIndexTypeUint8Features; + physicalDeviceShaderSMBuiltinsFeaturesNV.pNext = pNext; + pNext = &physicalDeviceShaderSMBuiltinsFeaturesNV; + physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceFragmentShaderInterlockFeaturesEXT; + physicalDeviceSeparateDepthStencilLayoutsFeatures.pNext = pNext; + pNext = &physicalDeviceSeparateDepthStencilLayoutsFeatures; + physicalDevicePrimitiveTopologyListRestartFeaturesEXT.pNext = pNext; + pNext = &physicalDevicePrimitiveTopologyListRestartFeaturesEXT; + physicalDevicePipelineExecutablePropertiesFeaturesKHR.pNext = pNext; + pNext = &physicalDevicePipelineExecutablePropertiesFeaturesKHR; + physicalDeviceShaderDemoteToHelperInvocationFeatures.pNext = pNext; + pNext = &physicalDeviceShaderDemoteToHelperInvocationFeatures; + physicalDeviceTexelBufferAlignmentFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceTexelBufferAlignmentFeaturesEXT; + physicalDeviceSubgroupSizeControlFeatures.pNext = pNext; + pNext = &physicalDeviceSubgroupSizeControlFeatures; + physicalDeviceLineRasterizationFeatures.pNext = pNext; + pNext = &physicalDeviceLineRasterizationFeatures; + physicalDevicePipelineCreationCacheControlFeatures.pNext = pNext; + pNext = &physicalDevicePipelineCreationCacheControlFeatures; + physicalDeviceVulkan11Features.pNext = pNext; + pNext = &physicalDeviceVulkan11Features; + physicalDeviceVulkan12Features.pNext = pNext; + pNext = &physicalDeviceVulkan12Features; + physicalDeviceVulkan13Features.pNext = pNext; + pNext = &physicalDeviceVulkan13Features; + physicalDeviceVulkan14Features.pNext = pNext; + pNext = &physicalDeviceVulkan14Features; + physicalDeviceCoherentMemoryFeaturesAMD.pNext = pNext; + pNext = &physicalDeviceCoherentMemoryFeaturesAMD; + physicalDeviceCustomBorderColorFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceCustomBorderColorFeaturesEXT; + physicalDeviceBorderColorSwizzleFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceBorderColorSwizzleFeaturesEXT; + physicalDeviceExtendedDynamicStateFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceExtendedDynamicStateFeaturesEXT; + physicalDeviceExtendedDynamicState2FeaturesEXT.pNext = pNext; + pNext = &physicalDeviceExtendedDynamicState2FeaturesEXT; + physicalDeviceExtendedDynamicState3FeaturesEXT.pNext = pNext; + pNext = &physicalDeviceExtendedDynamicState3FeaturesEXT; + physicalDevicePartitionedAccelerationStructureFeaturesNV.pNext = pNext; + pNext = &physicalDevicePartitionedAccelerationStructureFeaturesNV; + physicalDeviceDiagnosticsConfigFeaturesNV.pNext = pNext; + pNext = &physicalDeviceDiagnosticsConfigFeaturesNV; + physicalDeviceZeroInitializeWorkgroupMemoryFeatures.pNext = pNext; + pNext = &physicalDeviceZeroInitializeWorkgroupMemoryFeatures; + physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.pNext = pNext; + pNext = &physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; + physicalDeviceRobustness2FeaturesKHR.pNext = pNext; + pNext = &physicalDeviceRobustness2FeaturesKHR; + physicalDeviceImageRobustnessFeatures.pNext = pNext; + pNext = &physicalDeviceImageRobustnessFeatures; + physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.pNext = pNext; + pNext = &physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; #ifdef VK_ENABLE_BETA_EXTENSIONS - physicalDevicePortabilitySubsetFeaturesKHR.pNext = pNext; - pNext = &physicalDevicePortabilitySubsetFeaturesKHR; + physicalDevicePortabilitySubsetFeaturesKHR.pNext = pNext; + pNext = &physicalDevicePortabilitySubsetFeaturesKHR; #endif - physicalDevice4444FormatsFeaturesEXT.pNext = pNext; - pNext = &physicalDevice4444FormatsFeaturesEXT; - physicalDeviceSubpassShadingFeaturesHUAWEI.pNext = pNext; - pNext = &physicalDeviceSubpassShadingFeaturesHUAWEI; - physicalDeviceClusterCullingShaderFeaturesHUAWEI.pNext = pNext; - pNext = &physicalDeviceClusterCullingShaderFeaturesHUAWEI; - physicalDeviceShaderImageAtomicInt64FeaturesEXT.pNext = pNext; - pNext = &physicalDeviceShaderImageAtomicInt64FeaturesEXT; - physicalDeviceFragmentShadingRateFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceFragmentShadingRateFeaturesKHR; - physicalDeviceShaderTerminateInvocationFeatures.pNext = pNext; - pNext = &physicalDeviceShaderTerminateInvocationFeatures; - physicalDeviceFragmentShadingRateEnumsFeaturesNV.pNext = pNext; - pNext = &physicalDeviceFragmentShadingRateEnumsFeaturesNV; - physicalDeviceImage2DViewOf3DFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceImage2DViewOf3DFeaturesEXT; - physicalDeviceImageSlicedViewOf3DFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceImageSlicedViewOf3DFeaturesEXT; - physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; - physicalDeviceLegacyVertexAttributesFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceLegacyVertexAttributesFeaturesEXT; - physicalDeviceMutableDescriptorTypeFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceMutableDescriptorTypeFeaturesEXT; - physicalDeviceDepthClipControlFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceDepthClipControlFeaturesEXT; - physicalDeviceDeviceGeneratedCommandsFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceDeviceGeneratedCommandsFeaturesEXT; - physicalDeviceDepthClampControlFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceDepthClampControlFeaturesEXT; - physicalDeviceVertexInputDynamicStateFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceVertexInputDynamicStateFeaturesEXT; - physicalDeviceExternalMemoryRDMAFeaturesNV.pNext = pNext; - pNext = &physicalDeviceExternalMemoryRDMAFeaturesNV; - physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; - physicalDeviceColorWriteEnableFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceColorWriteEnableFeaturesEXT; - physicalDeviceSynchronization2Features.pNext = pNext; - pNext = &physicalDeviceSynchronization2Features; - physicalDeviceHostImageCopyFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceHostImageCopyFeaturesEXT; - physicalDevicePrimitivesGeneratedQueryFeaturesEXT.pNext = pNext; - pNext = &physicalDevicePrimitivesGeneratedQueryFeaturesEXT; - physicalDeviceLegacyDitheringFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceLegacyDitheringFeaturesEXT; - physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; - physicalDevicePipelineProtectedAccessFeaturesEXT.pNext = pNext; - pNext = &physicalDevicePipelineProtectedAccessFeaturesEXT; - physicalDeviceVideoMaintenance1FeaturesKHR.pNext = pNext; - pNext = &physicalDeviceVideoMaintenance1FeaturesKHR; - physicalDeviceInheritedViewportScissorFeaturesNV.pNext = pNext; - pNext = &physicalDeviceInheritedViewportScissorFeaturesNV; - physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceYcbcr2Plane444FormatsFeaturesEXT; - physicalDeviceProvokingVertexFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceProvokingVertexFeaturesEXT; - physicalDeviceDescriptorBufferFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceDescriptorBufferFeaturesEXT; - physicalDeviceShaderIntegerDotProductFeatures.pNext = pNext; - pNext = &physicalDeviceShaderIntegerDotProductFeatures; - physicalDeviceFragmentShaderBarycentricFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceFragmentShaderBarycentricFeaturesKHR; - physicalDeviceRayTracingMotionBlurFeaturesNV.pNext = pNext; - pNext = &physicalDeviceRayTracingMotionBlurFeaturesNV; - physicalDeviceRayTracingValidationFeaturesNV.pNext = pNext; - pNext = &physicalDeviceRayTracingValidationFeaturesNV; - physicalDeviceRGBA10X6FormatsFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceRGBA10X6FormatsFeaturesEXT; - physicalDeviceDynamicRenderingFeatures.pNext = pNext; - pNext = &physicalDeviceDynamicRenderingFeatures; - physicalDeviceImageViewMinLodFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceImageViewMinLodFeaturesEXT; - physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; - physicalDeviceLinearColorAttachmentFeaturesNV.pNext = pNext; - pNext = &physicalDeviceLinearColorAttachmentFeaturesNV; - physicalDeviceGraphicsPipelineLibraryFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceGraphicsPipelineLibraryFeaturesEXT; - physicalDevicePipelineBinaryFeaturesKHR.pNext = pNext; - pNext = &physicalDevicePipelineBinaryFeaturesKHR; - physicalDeviceDescriptorSetHostMappingFeaturesVALVE.pNext = pNext; - pNext = &physicalDeviceDescriptorSetHostMappingFeaturesVALVE; - physicalDeviceNestedCommandBufferFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceNestedCommandBufferFeaturesEXT; - physicalDeviceShaderModuleIdentifierFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceShaderModuleIdentifierFeaturesEXT; - physicalDeviceImageCompressionControlFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceImageCompressionControlFeaturesEXT; - physicalDeviceImageCompressionControlSwapchainFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceImageCompressionControlSwapchainFeaturesEXT; - physicalDeviceSubpassMergeFeedbackFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceSubpassMergeFeedbackFeaturesEXT; - physicalDeviceOpacityMicromapFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceOpacityMicromapFeaturesEXT; + physicalDevice4444FormatsFeaturesEXT.pNext = pNext; + pNext = &physicalDevice4444FormatsFeaturesEXT; + physicalDeviceSubpassShadingFeaturesHUAWEI.pNext = pNext; + pNext = &physicalDeviceSubpassShadingFeaturesHUAWEI; + physicalDeviceClusterCullingShaderFeaturesHUAWEI.pNext = pNext; + pNext = &physicalDeviceClusterCullingShaderFeaturesHUAWEI; + physicalDeviceShaderImageAtomicInt64FeaturesEXT.pNext = pNext; + pNext = &physicalDeviceShaderImageAtomicInt64FeaturesEXT; + physicalDeviceFragmentShadingRateFeaturesKHR.pNext = pNext; + pNext = &physicalDeviceFragmentShadingRateFeaturesKHR; + physicalDeviceShaderTerminateInvocationFeatures.pNext = pNext; + pNext = &physicalDeviceShaderTerminateInvocationFeatures; + physicalDeviceFragmentShadingRateEnumsFeaturesNV.pNext = pNext; + pNext = &physicalDeviceFragmentShadingRateEnumsFeaturesNV; + physicalDeviceImage2DViewOf3DFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceImage2DViewOf3DFeaturesEXT; + physicalDeviceImageSlicedViewOf3DFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceImageSlicedViewOf3DFeaturesEXT; + physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; + physicalDeviceLegacyVertexAttributesFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceLegacyVertexAttributesFeaturesEXT; + physicalDeviceMutableDescriptorTypeFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceMutableDescriptorTypeFeaturesEXT; + physicalDeviceDepthClipControlFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceDepthClipControlFeaturesEXT; + physicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; + physicalDeviceDeviceGeneratedCommandsFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceDeviceGeneratedCommandsFeaturesEXT; + physicalDeviceDepthClampControlFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceDepthClampControlFeaturesEXT; + physicalDeviceVertexInputDynamicStateFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceVertexInputDynamicStateFeaturesEXT; + physicalDeviceExternalMemoryRDMAFeaturesNV.pNext = pNext; + pNext = &physicalDeviceExternalMemoryRDMAFeaturesNV; + physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.pNext = pNext; + pNext = &physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; + physicalDeviceColorWriteEnableFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceColorWriteEnableFeaturesEXT; + physicalDeviceSynchronization2Features.pNext = pNext; + pNext = &physicalDeviceSynchronization2Features; + physicalDeviceUnifiedImageLayoutsFeaturesKHR.pNext = pNext; + pNext = &physicalDeviceUnifiedImageLayoutsFeaturesKHR; + physicalDeviceHostImageCopyFeatures.pNext = pNext; + pNext = &physicalDeviceHostImageCopyFeatures; + physicalDevicePrimitivesGeneratedQueryFeaturesEXT.pNext = pNext; + pNext = &physicalDevicePrimitivesGeneratedQueryFeaturesEXT; + physicalDeviceLegacyDitheringFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceLegacyDitheringFeaturesEXT; + physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; + physicalDevicePipelineProtectedAccessFeatures.pNext = pNext; + pNext = &physicalDevicePipelineProtectedAccessFeatures; + physicalDeviceVideoMaintenance1FeaturesKHR.pNext = pNext; + pNext = &physicalDeviceVideoMaintenance1FeaturesKHR; + physicalDeviceVideoMaintenance2FeaturesKHR.pNext = pNext; + pNext = &physicalDeviceVideoMaintenance2FeaturesKHR; + physicalDeviceVideoDecodeVP9FeaturesKHR.pNext = pNext; + pNext = &physicalDeviceVideoDecodeVP9FeaturesKHR; + physicalDeviceVideoEncodeQuantizationMapFeaturesKHR.pNext = pNext; + pNext = &physicalDeviceVideoEncodeQuantizationMapFeaturesKHR; + physicalDeviceVideoEncodeAV1FeaturesKHR.pNext = pNext; + pNext = &physicalDeviceVideoEncodeAV1FeaturesKHR; + physicalDeviceInheritedViewportScissorFeaturesNV.pNext = pNext; + pNext = &physicalDeviceInheritedViewportScissorFeaturesNV; + physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceYcbcr2Plane444FormatsFeaturesEXT; + physicalDeviceProvokingVertexFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceProvokingVertexFeaturesEXT; + physicalDeviceVideoEncodeIntraRefreshFeaturesKHR.pNext = pNext; + pNext = &physicalDeviceVideoEncodeIntraRefreshFeaturesKHR; + physicalDeviceDescriptorBufferFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceDescriptorBufferFeaturesEXT; + physicalDeviceShaderIntegerDotProductFeatures.pNext = pNext; + pNext = &physicalDeviceShaderIntegerDotProductFeatures; + physicalDeviceFragmentShaderBarycentricFeaturesKHR.pNext = pNext; + pNext = &physicalDeviceFragmentShaderBarycentricFeaturesKHR; + physicalDeviceRayTracingMotionBlurFeaturesNV.pNext = pNext; + pNext = &physicalDeviceRayTracingMotionBlurFeaturesNV; + physicalDeviceRayTracingValidationFeaturesNV.pNext = pNext; + pNext = &physicalDeviceRayTracingValidationFeaturesNV; + physicalDeviceRayTracingLinearSweptSpheresFeaturesNV.pNext = pNext; + pNext = &physicalDeviceRayTracingLinearSweptSpheresFeaturesNV; + physicalDeviceRGBA10X6FormatsFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceRGBA10X6FormatsFeaturesEXT; + physicalDeviceDynamicRenderingFeatures.pNext = pNext; + pNext = &physicalDeviceDynamicRenderingFeatures; + physicalDeviceImageViewMinLodFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceImageViewMinLodFeaturesEXT; + physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; + physicalDeviceLinearColorAttachmentFeaturesNV.pNext = pNext; + pNext = &physicalDeviceLinearColorAttachmentFeaturesNV; + physicalDeviceGraphicsPipelineLibraryFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceGraphicsPipelineLibraryFeaturesEXT; + physicalDevicePipelineBinaryFeaturesKHR.pNext = pNext; + pNext = &physicalDevicePipelineBinaryFeaturesKHR; + physicalDeviceDescriptorSetHostMappingFeaturesVALVE.pNext = pNext; + pNext = &physicalDeviceDescriptorSetHostMappingFeaturesVALVE; + physicalDeviceNestedCommandBufferFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceNestedCommandBufferFeaturesEXT; + physicalDeviceShaderModuleIdentifierFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceShaderModuleIdentifierFeaturesEXT; + physicalDeviceImageCompressionControlFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceImageCompressionControlFeaturesEXT; + physicalDeviceImageCompressionControlSwapchainFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceImageCompressionControlSwapchainFeaturesEXT; + physicalDeviceSubpassMergeFeedbackFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceSubpassMergeFeedbackFeaturesEXT; + physicalDeviceOpacityMicromapFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceOpacityMicromapFeaturesEXT; #ifdef VK_ENABLE_BETA_EXTENSIONS - physicalDeviceDisplacementMicromapFeaturesNV.pNext = pNext; - pNext = &physicalDeviceDisplacementMicromapFeaturesNV; + physicalDeviceDisplacementMicromapFeaturesNV.pNext = pNext; + pNext = &physicalDeviceDisplacementMicromapFeaturesNV; #endif - physicalDevicePipelinePropertiesFeaturesEXT.pNext = pNext; - pNext = &physicalDevicePipelinePropertiesFeaturesEXT; - physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.pNext = pNext; - pNext = &physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; - physicalDeviceNonSeamlessCubeMapFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceNonSeamlessCubeMapFeaturesEXT; - physicalDevicePipelineRobustnessFeaturesEXT.pNext = pNext; - pNext = &physicalDevicePipelineRobustnessFeaturesEXT; - physicalDeviceImageProcessingFeaturesQCOM.pNext = pNext; - pNext = &physicalDeviceImageProcessingFeaturesQCOM; - physicalDeviceTilePropertiesFeaturesQCOM.pNext = pNext; - pNext = &physicalDeviceTilePropertiesFeaturesQCOM; - physicalDeviceAmigoProfilingFeaturesSEC.pNext = pNext; - pNext = &physicalDeviceAmigoProfilingFeaturesSEC; - physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; - physicalDeviceDepthClampZeroOneFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceDepthClampZeroOneFeaturesEXT; - physicalDeviceAddressBindingReportFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceAddressBindingReportFeaturesEXT; - physicalDeviceOpticalFlowFeaturesNV.pNext = pNext; - pNext = &physicalDeviceOpticalFlowFeaturesNV; - physicalDeviceFaultFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceFaultFeaturesEXT; - physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.pNext = pNext; - pNext = &physicalDevicePipelineLibraryGroupHandlesFeaturesEXT; - physicalDeviceShaderCoreBuiltinsFeaturesARM.pNext = pNext; - pNext = &physicalDeviceShaderCoreBuiltinsFeaturesARM; - physicalDeviceFrameBoundaryFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceFrameBoundaryFeaturesEXT; - physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; - physicalDeviceSwapchainMaintenance1FeaturesEXT.pNext = pNext; - pNext = &physicalDeviceSwapchainMaintenance1FeaturesEXT; - physicalDeviceDepthBiasControlFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceDepthBiasControlFeaturesEXT; - physicalDeviceRayTracingInvocationReorderFeaturesNV.pNext = pNext; - pNext = &physicalDeviceRayTracingInvocationReorderFeaturesNV; - physicalDeviceExtendedSparseAddressSpaceFeaturesNV.pNext = pNext; - pNext = &physicalDeviceExtendedSparseAddressSpaceFeaturesNV; - physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.pNext = pNext; - pNext = &physicalDeviceMultiviewPerViewViewportsFeaturesQCOM; - physicalDeviceRayTracingPositionFetchFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceRayTracingPositionFetchFeaturesKHR; - physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.pNext = pNext; - pNext = &physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; - physicalDeviceShaderObjectFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceShaderObjectFeaturesEXT; - physicalDeviceShaderTileImageFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceShaderTileImageFeaturesEXT; + physicalDevicePipelinePropertiesFeaturesEXT.pNext = pNext; + pNext = &physicalDevicePipelinePropertiesFeaturesEXT; + physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.pNext = pNext; + pNext = &physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; + physicalDeviceNonSeamlessCubeMapFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceNonSeamlessCubeMapFeaturesEXT; + physicalDevicePipelineRobustnessFeatures.pNext = pNext; + pNext = &physicalDevicePipelineRobustnessFeatures; + physicalDeviceImageProcessingFeaturesQCOM.pNext = pNext; + pNext = &physicalDeviceImageProcessingFeaturesQCOM; + physicalDeviceTilePropertiesFeaturesQCOM.pNext = pNext; + pNext = &physicalDeviceTilePropertiesFeaturesQCOM; + physicalDeviceAmigoProfilingFeaturesSEC.pNext = pNext; + pNext = &physicalDeviceAmigoProfilingFeaturesSEC; + physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; + physicalDeviceAddressBindingReportFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceAddressBindingReportFeaturesEXT; + physicalDeviceOpticalFlowFeaturesNV.pNext = pNext; + pNext = &physicalDeviceOpticalFlowFeaturesNV; + physicalDeviceFaultFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceFaultFeaturesEXT; + physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.pNext = pNext; + pNext = &physicalDevicePipelineLibraryGroupHandlesFeaturesEXT; + physicalDeviceShaderCoreBuiltinsFeaturesARM.pNext = pNext; + pNext = &physicalDeviceShaderCoreBuiltinsFeaturesARM; + physicalDeviceFrameBoundaryFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceFrameBoundaryFeaturesEXT; + physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; + physicalDeviceSwapchainMaintenance1FeaturesKHR.pNext = pNext; + pNext = &physicalDeviceSwapchainMaintenance1FeaturesKHR; + physicalDeviceDepthBiasControlFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceDepthBiasControlFeaturesEXT; + physicalDeviceRayTracingInvocationReorderFeaturesNV.pNext = pNext; + pNext = &physicalDeviceRayTracingInvocationReorderFeaturesNV; + physicalDeviceExtendedSparseAddressSpaceFeaturesNV.pNext = pNext; + pNext = &physicalDeviceExtendedSparseAddressSpaceFeaturesNV; + physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.pNext = pNext; + pNext = &physicalDeviceMultiviewPerViewViewportsFeaturesQCOM; + physicalDeviceRayTracingPositionFetchFeaturesKHR.pNext = pNext; + pNext = &physicalDeviceRayTracingPositionFetchFeaturesKHR; + physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.pNext = pNext; + pNext = &physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; + physicalDeviceShaderObjectFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceShaderObjectFeaturesEXT; + physicalDeviceShaderTileImageFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceShaderTileImageFeaturesEXT; #ifdef VK_USE_PLATFORM_SCREEN_QNX - physicalDeviceExternalMemoryScreenBufferFeaturesQNX.pNext = pNext; - pNext = &physicalDeviceExternalMemoryScreenBufferFeaturesQNX; + physicalDeviceExternalMemoryScreenBufferFeaturesQNX.pNext = pNext; + pNext = &physicalDeviceExternalMemoryScreenBufferFeaturesQNX; #endif - physicalDeviceCooperativeMatrixFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceCooperativeMatrixFeaturesKHR; + physicalDeviceCooperativeMatrixFeaturesKHR.pNext = pNext; + pNext = &physicalDeviceCooperativeMatrixFeaturesKHR; #ifdef VK_ENABLE_BETA_EXTENSIONS - physicalDeviceShaderEnqueueFeaturesAMDX.pNext = pNext; - pNext = &physicalDeviceShaderEnqueueFeaturesAMDX; + physicalDeviceShaderEnqueueFeaturesAMDX.pNext = pNext; + pNext = &physicalDeviceShaderEnqueueFeaturesAMDX; #endif - physicalDeviceAntiLagFeaturesAMD.pNext = pNext; - pNext = &physicalDeviceAntiLagFeaturesAMD; - physicalDeviceCubicClampFeaturesQCOM.pNext = pNext; - pNext = &physicalDeviceCubicClampFeaturesQCOM; - physicalDeviceYcbcrDegammaFeaturesQCOM.pNext = pNext; - pNext = &physicalDeviceYcbcrDegammaFeaturesQCOM; - physicalDeviceCubicWeightsFeaturesQCOM.pNext = pNext; - pNext = &physicalDeviceCubicWeightsFeaturesQCOM; - physicalDeviceImageProcessing2FeaturesQCOM.pNext = pNext; - pNext = &physicalDeviceImageProcessing2FeaturesQCOM; - physicalDeviceDescriptorPoolOverallocationFeaturesNV.pNext = pNext; - pNext = &physicalDeviceDescriptorPoolOverallocationFeaturesNV; - physicalDevicePerStageDescriptorSetFeaturesNV.pNext = pNext; - pNext = &physicalDevicePerStageDescriptorSetFeaturesNV; + physicalDeviceAntiLagFeaturesAMD.pNext = pNext; + pNext = &physicalDeviceAntiLagFeaturesAMD; + physicalDeviceTileMemoryHeapFeaturesQCOM.pNext = pNext; + pNext = &physicalDeviceTileMemoryHeapFeaturesQCOM; + physicalDeviceCubicClampFeaturesQCOM.pNext = pNext; + pNext = &physicalDeviceCubicClampFeaturesQCOM; + physicalDeviceYcbcrDegammaFeaturesQCOM.pNext = pNext; + pNext = &physicalDeviceYcbcrDegammaFeaturesQCOM; + physicalDeviceCubicWeightsFeaturesQCOM.pNext = pNext; + pNext = &physicalDeviceCubicWeightsFeaturesQCOM; + physicalDeviceImageProcessing2FeaturesQCOM.pNext = pNext; + pNext = &physicalDeviceImageProcessing2FeaturesQCOM; + physicalDeviceDescriptorPoolOverallocationFeaturesNV.pNext = pNext; + pNext = &physicalDeviceDescriptorPoolOverallocationFeaturesNV; + physicalDevicePerStageDescriptorSetFeaturesNV.pNext = pNext; + pNext = &physicalDevicePerStageDescriptorSetFeaturesNV; #ifdef VK_USE_PLATFORM_ANDROID_KHR - physicalDeviceExternalFormatResolveFeaturesANDROID.pNext = pNext; - pNext = &physicalDeviceExternalFormatResolveFeaturesANDROID; + physicalDeviceExternalFormatResolveFeaturesANDROID.pNext = pNext; + pNext = &physicalDeviceExternalFormatResolveFeaturesANDROID; +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + physicalDeviceCudaKernelLaunchFeaturesNV.pNext = pNext; + pNext = &physicalDeviceCudaKernelLaunchFeaturesNV; +#endif + physicalDeviceSchedulingControlsFeaturesARM.pNext = pNext; + pNext = &physicalDeviceSchedulingControlsFeaturesARM; + physicalDeviceRelaxedLineRasterizationFeaturesIMG.pNext = pNext; + pNext = &physicalDeviceRelaxedLineRasterizationFeaturesIMG; + physicalDeviceRenderPassStripedFeaturesARM.pNext = pNext; + pNext = &physicalDeviceRenderPassStripedFeaturesARM; + physicalDevicePipelineOpacityMicromapFeaturesARM.pNext = pNext; + pNext = &physicalDevicePipelineOpacityMicromapFeaturesARM; + physicalDeviceShaderMaximalReconvergenceFeaturesKHR.pNext = pNext; + pNext = &physicalDeviceShaderMaximalReconvergenceFeaturesKHR; + physicalDeviceShaderSubgroupRotateFeatures.pNext = pNext; + pNext = &physicalDeviceShaderSubgroupRotateFeatures; + physicalDeviceShaderExpectAssumeFeatures.pNext = pNext; + pNext = &physicalDeviceShaderExpectAssumeFeatures; + physicalDeviceShaderFloatControls2Features.pNext = pNext; + pNext = &physicalDeviceShaderFloatControls2Features; + physicalDeviceDynamicRenderingLocalReadFeatures.pNext = pNext; + pNext = &physicalDeviceDynamicRenderingLocalReadFeatures; + physicalDeviceShaderQuadControlFeaturesKHR.pNext = pNext; + pNext = &physicalDeviceShaderQuadControlFeaturesKHR; + physicalDeviceShaderAtomicFloat16VectorFeaturesNV.pNext = pNext; + pNext = &physicalDeviceShaderAtomicFloat16VectorFeaturesNV; + physicalDeviceMapMemoryPlacedFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceMapMemoryPlacedFeaturesEXT; + physicalDeviceShaderBfloat16FeaturesKHR.pNext = pNext; + pNext = &physicalDeviceShaderBfloat16FeaturesKHR; + physicalDeviceRawAccessChainsFeaturesNV.pNext = pNext; + pNext = &physicalDeviceRawAccessChainsFeaturesNV; + physicalDeviceCommandBufferInheritanceFeaturesNV.pNext = pNext; + pNext = &physicalDeviceCommandBufferInheritanceFeaturesNV; + physicalDeviceImageAlignmentControlFeaturesMESA.pNext = pNext; + pNext = &physicalDeviceImageAlignmentControlFeaturesMESA; + physicalDeviceShaderReplicatedCompositesFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceShaderReplicatedCompositesFeaturesEXT; + physicalDevicePresentModeFifoLatestReadyFeaturesKHR.pNext = pNext; + pNext = &physicalDevicePresentModeFifoLatestReadyFeaturesKHR; + physicalDeviceCooperativeMatrix2FeaturesNV.pNext = pNext; + pNext = &physicalDeviceCooperativeMatrix2FeaturesNV; + physicalDeviceHdrVividFeaturesHUAWEI.pNext = pNext; + pNext = &physicalDeviceHdrVividFeaturesHUAWEI; + physicalDeviceVertexAttributeRobustnessFeaturesEXT.pNext = pNext; + pNext = &physicalDeviceVertexAttributeRobustnessFeaturesEXT; + physicalDeviceDepthClampZeroOneFeaturesKHR.pNext = pNext; + pNext = &physicalDeviceDepthClampZeroOneFeaturesKHR; + physicalDeviceCooperativeVectorFeaturesNV.pNext = pNext; + pNext = &physicalDeviceCooperativeVectorFeaturesNV; + physicalDeviceTileShadingFeaturesQCOM.pNext = pNext; + pNext = &physicalDeviceTileShadingFeaturesQCOM; + physicalDeviceFragmentDensityMapLayeredFeaturesVALVE.pNext = pNext; + pNext = &physicalDeviceFragmentDensityMapLayeredFeaturesVALVE; +#ifdef VK_ENABLE_BETA_EXTENSIONS + physicalDevicePresentMeteringFeaturesNV.pNext = pNext; + pNext = &physicalDevicePresentMeteringFeaturesNV; #endif - physicalDeviceCudaKernelLaunchFeaturesNV.pNext = pNext; - pNext = &physicalDeviceCudaKernelLaunchFeaturesNV; - physicalDeviceSchedulingControlsFeaturesARM.pNext = pNext; - pNext = &physicalDeviceSchedulingControlsFeaturesARM; - physicalDeviceRelaxedLineRasterizationFeaturesIMG.pNext = pNext; - pNext = &physicalDeviceRelaxedLineRasterizationFeaturesIMG; - physicalDeviceRenderPassStripedFeaturesARM.pNext = pNext; - pNext = &physicalDeviceRenderPassStripedFeaturesARM; - physicalDeviceShaderMaximalReconvergenceFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceShaderMaximalReconvergenceFeaturesKHR; - physicalDeviceShaderSubgroupRotateFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceShaderSubgroupRotateFeaturesKHR; - physicalDeviceShaderExpectAssumeFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceShaderExpectAssumeFeaturesKHR; - physicalDeviceShaderFloatControls2FeaturesKHR.pNext = pNext; - pNext = &physicalDeviceShaderFloatControls2FeaturesKHR; - physicalDeviceDynamicRenderingLocalReadFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceDynamicRenderingLocalReadFeaturesKHR; - physicalDeviceShaderQuadControlFeaturesKHR.pNext = pNext; - pNext = &physicalDeviceShaderQuadControlFeaturesKHR; - physicalDeviceShaderAtomicFloat16VectorFeaturesNV.pNext = pNext; - pNext = &physicalDeviceShaderAtomicFloat16VectorFeaturesNV; - physicalDeviceMapMemoryPlacedFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceMapMemoryPlacedFeaturesEXT; - physicalDeviceRawAccessChainsFeaturesNV.pNext = pNext; - pNext = &physicalDeviceRawAccessChainsFeaturesNV; - physicalDeviceCommandBufferInheritanceFeaturesNV.pNext = pNext; - pNext = &physicalDeviceCommandBufferInheritanceFeaturesNV; - physicalDeviceImageAlignmentControlFeaturesMESA.pNext = pNext; - pNext = &physicalDeviceImageAlignmentControlFeaturesMESA; - physicalDeviceShaderReplicatedCompositesFeaturesEXT.pNext = pNext; - pNext = &physicalDeviceShaderReplicatedCompositesFeaturesEXT; - physicalDevicePresentModeFifoLatestReadyFeaturesEXT.pNext = pNext; - pNext = &physicalDevicePresentModeFifoLatestReadyFeaturesEXT; - physicalDeviceFeatures2KHR.pNext = pNext; - - } - - - VkPhysicalDeviceFeatures2KHR requiredFeaturesChain{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, nullptr}; - VkBaseOutStructure* current = nullptr; - - void ApplyRobustness(const VpDeviceCreateInfo* pCreateInfo) { + physicalDeviceFormatPackFeaturesARM.pNext = pNext; + pNext = &physicalDeviceFormatPackFeaturesARM; + physicalDeviceTensorFeaturesARM.pNext = pNext; + pNext = &physicalDeviceTensorFeaturesARM; + physicalDeviceDescriptorBufferTensorFeaturesARM.pNext = pNext; + pNext = &physicalDeviceDescriptorBufferTensorFeaturesARM; + physicalDeviceShaderFloat8FeaturesEXT.pNext = pNext; + pNext = &physicalDeviceShaderFloat8FeaturesEXT; + physicalDeviceDataGraphFeaturesARM.pNext = pNext; + pNext = &physicalDeviceDataGraphFeaturesARM; + physicalDevicePipelineCacheIncrementalModeFeaturesSEC.pNext = pNext; + pNext = &physicalDevicePipelineCacheIncrementalModeFeaturesSEC; + physicalDeviceFeatures2KHR.pNext = pNext; + } + + VkPhysicalDeviceFeatures2KHR requiredFeaturesChain{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, nullptr}; + VkBaseOutStructure *current = nullptr; + + void ApplyRobustness(const VpDeviceCreateInfo *pCreateInfo) + { #ifdef VK_VERSION_1_1 - VkPhysicalDeviceFeatures2KHR* pFeatures2 = static_cast( - vpGetStructure(&this->requiredFeaturesChain, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR)); - if (pFeatures2 != nullptr && (pCreateInfo->flags & VP_DEVICE_CREATE_DISABLE_ROBUST_BUFFER_ACCESS_BIT)) { - pFeatures2->features.robustBufferAccess = VK_FALSE; - } + VkPhysicalDeviceFeatures2KHR *pFeatures2 = static_cast( + vpGetStructure(&this->requiredFeaturesChain, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR)); + if (pFeatures2 != nullptr && (pCreateInfo->flags & VP_DEVICE_CREATE_DISABLE_ROBUST_BUFFER_ACCESS_BIT)) + { + pFeatures2->features.robustBufferAccess = VK_FALSE; + } #endif #ifdef VK_EXT_robustness2 - VkPhysicalDeviceRobustness2FeaturesEXT* pRobustness2FeaturesEXT = static_cast( - vpGetStructure(&this->requiredFeaturesChain, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT)); - if (pRobustness2FeaturesEXT != nullptr) { - if (pCreateInfo->flags & VP_DEVICE_CREATE_DISABLE_ROBUST_BUFFER_ACCESS_BIT) { - pRobustness2FeaturesEXT->robustBufferAccess2 = VK_FALSE; - } - if (pCreateInfo->flags & VP_DEVICE_CREATE_DISABLE_ROBUST_IMAGE_ACCESS_BIT) { - pRobustness2FeaturesEXT->robustImageAccess2 = VK_FALSE; - } - } + VkPhysicalDeviceRobustness2FeaturesEXT *pRobustness2FeaturesEXT = static_cast( + vpGetStructure(&this->requiredFeaturesChain, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT)); + if (pRobustness2FeaturesEXT != nullptr) + { + if (pCreateInfo->flags & VP_DEVICE_CREATE_DISABLE_ROBUST_BUFFER_ACCESS_BIT) + { + pRobustness2FeaturesEXT->robustBufferAccess2 = VK_FALSE; + } + if (pCreateInfo->flags & VP_DEVICE_CREATE_DISABLE_ROBUST_IMAGE_ACCESS_BIT) + { + pRobustness2FeaturesEXT->robustImageAccess2 = VK_FALSE; + } + } #endif #ifdef VK_EXT_image_robustness - VkPhysicalDeviceImageRobustnessFeaturesEXT* pImageRobustnessFeaturesEXT = - static_cast(vpGetStructure( - &this->requiredFeaturesChain, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT)); - if (pImageRobustnessFeaturesEXT != nullptr && (pCreateInfo->flags & VP_DEVICE_CREATE_DISABLE_ROBUST_IMAGE_ACCESS_BIT)) { - pImageRobustnessFeaturesEXT->robustImageAccess = VK_FALSE; - } + VkPhysicalDeviceImageRobustnessFeaturesEXT *pImageRobustnessFeaturesEXT = + static_cast(vpGetStructure( + &this->requiredFeaturesChain, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT)); + if (pImageRobustnessFeaturesEXT != nullptr && (pCreateInfo->flags & VP_DEVICE_CREATE_DISABLE_ROBUST_IMAGE_ACCESS_BIT)) + { + pImageRobustnessFeaturesEXT->robustImageAccess = VK_FALSE; + } #endif #ifdef VK_VERSION_1_3 - VkPhysicalDeviceVulkan13Features* pVulkan13Features = static_cast( - vpGetStructure(&this->requiredFeaturesChain, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES)); - if (pVulkan13Features != nullptr && (pCreateInfo->flags & VP_DEVICE_CREATE_DISABLE_ROBUST_IMAGE_ACCESS_BIT)) { - pVulkan13Features->robustImageAccess = VK_FALSE; - } + VkPhysicalDeviceVulkan13Features *pVulkan13Features = static_cast( + vpGetStructure(&this->requiredFeaturesChain, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES)); + if (pVulkan13Features != nullptr && (pCreateInfo->flags & VP_DEVICE_CREATE_DISABLE_ROBUST_IMAGE_ACCESS_BIT)) + { + pVulkan13Features->robustImageAccess = VK_FALSE; + } #endif - } - - void ApplyFeatures(const VpDeviceCreateInfo* pCreateInfo) { - const std::size_t offset = sizeof(VkBaseOutStructure); - const VkBaseOutStructure* q = reinterpret_cast(pCreateInfo->pCreateInfo->pNext); - while (q) { - const std::size_t count = this->structureSize[q->sType]; - for (std::size_t index = 0; index < count; ++index) { - const VkBaseOutStructure* pInputStruct = reinterpret_cast(q); - VkBaseOutStructure* pOutputStruct = reinterpret_cast(detail::vpGetStructure(&this->requiredFeaturesChain, q->sType)); - const uint8_t* pInputData = reinterpret_cast(pInputStruct) + offset; - uint8_t* pOutputData = reinterpret_cast(pOutputStruct) + offset; - const VkBool32* input = reinterpret_cast(pInputData); - VkBool32* output = reinterpret_cast(pOutputData); - - output[index] = (output[index] == VK_TRUE || input[index] == VK_TRUE) ? VK_TRUE : VK_FALSE; - } - q = q->pNext; - } - - this->ApplyRobustness(pCreateInfo); - } - - void PushBack(VkBaseOutStructure* found) { - VkBaseOutStructure* last = reinterpret_cast(&requiredFeaturesChain); - while (last->pNext != nullptr) { - last = last->pNext; - } - last->pNext = found; - } - - void Build(const std::vector& requiredList) { - for (std::size_t i = 0, n = requiredList.size(); i < n; ++i) { - const VkStructureType sType = requiredList[i]; - if (sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR) { - continue; - } - - VkBaseOutStructure* found = vpExtractStructure(&physicalDeviceFeatures2KHR, sType); - if (found == nullptr) { - continue; - } - - PushBack(found); - } - } -}; // struct FeaturesChain - -VPAPI_ATTR const VpProfileDesc* vpGetProfileDesc(const char profileName[VP_MAX_PROFILE_NAME_SIZE]) { - for (uint32_t profileIndex = 0; profileIndex < profileCount; ++profileIndex) { - if (strncmp(profiles[profileIndex].props.profileName, profileName, VP_MAX_PROFILE_NAME_SIZE) == 0) { - return &profiles[profileIndex]; - } - } - return nullptr; + } + + void ApplyFeatures(const VpDeviceCreateInfo *pCreateInfo) + { + const std::size_t offset = sizeof(VkBaseOutStructure); + const VkBaseOutStructure *q = reinterpret_cast(pCreateInfo->pCreateInfo->pNext); + while (q) + { + const std::size_t count = this->structureSize[q->sType]; + for (std::size_t index = 0; index < count; ++index) + { + const VkBaseOutStructure *pInputStruct = reinterpret_cast(q); + VkBaseOutStructure *pOutputStruct = reinterpret_cast(detail::vpGetStructure(&this->requiredFeaturesChain, q->sType)); + const uint8_t *pInputData = reinterpret_cast(pInputStruct) + offset; + uint8_t *pOutputData = reinterpret_cast(pOutputStruct) + offset; + const VkBool32 *input = reinterpret_cast(pInputData); + VkBool32 *output = reinterpret_cast(pOutputData); + + output[index] = (output[index] == VK_TRUE || input[index] == VK_TRUE) ? VK_TRUE : VK_FALSE; + } + q = q->pNext; + } + + this->ApplyRobustness(pCreateInfo); + } + + void PushBack(VkBaseOutStructure *found) + { + VkBaseOutStructure *last = reinterpret_cast(&requiredFeaturesChain); + while (last->pNext != nullptr) + { + last = last->pNext; + } + last->pNext = found; + } + + void Build(const std::vector &requiredList) + { + for (std::size_t i = 0, n = requiredList.size(); i < n; ++i) + { + const VkStructureType sType = requiredList[i]; + if (sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR) + { + continue; + } + + VkBaseOutStructure *found = vpExtractStructure(&physicalDeviceFeatures2KHR, sType); + if (found == nullptr) + { + continue; + } + + PushBack(found); + } + } +}; // struct FeaturesChain + +VPAPI_ATTR const VpProfileDesc *vpGetProfileDesc(const char profileName[VP_MAX_PROFILE_NAME_SIZE]) +{ + for (uint32_t profileIndex = 0; profileIndex < profileCount; ++profileIndex) + { + if (strncmp(profiles[profileIndex].props.profileName, profileName, VP_MAX_PROFILE_NAME_SIZE) == 0) + { + return &profiles[profileIndex]; + } + } + return nullptr; } -VPAPI_ATTR std::vector GatherProfiles(const VpProfileProperties& profile, const char* pBlockName = nullptr) { - std::vector gatheredProfiles; - - if (pBlockName == nullptr) { - const detail::VpProfileDesc* profileDesc = detail::vpGetProfileDesc(profile.profileName); - if (profileDesc != nullptr) { - for (uint32_t profileIndex = 0; profileIndex < profileDesc->requiredProfileCount; ++profileIndex) { - gatheredProfiles.push_back(profileDesc->pRequiredProfiles[profileIndex]); - } - } - } - - gatheredProfiles.push_back(profile); - - return gatheredProfiles; +VPAPI_ATTR std::vector GatherProfiles(const VpProfileProperties &profile, const char *pBlockName = nullptr) +{ + std::vector gatheredProfiles; + + if (pBlockName == nullptr) + { + const detail::VpProfileDesc *profileDesc = detail::vpGetProfileDesc(profile.profileName); + if (profileDesc != nullptr) + { + for (uint32_t profileIndex = 0; profileIndex < profileDesc->requiredProfileCount; ++profileIndex) + { + gatheredProfiles.push_back(profileDesc->pRequiredProfiles[profileIndex]); + } + } + } + + gatheredProfiles.push_back(profile); + + return gatheredProfiles; } -VPAPI_ATTR bool vpCheckVersion(uint32_t actual, uint32_t expected) { - uint32_t actualMajor = VK_API_VERSION_MAJOR(actual); - uint32_t actualMinor = VK_API_VERSION_MINOR(actual); - uint32_t expectedMajor = VK_API_VERSION_MAJOR(expected); - uint32_t expectedMinor = VK_API_VERSION_MINOR(expected); - return actualMajor > expectedMajor || (actualMajor == expectedMajor && actualMinor >= expectedMinor); +VPAPI_ATTR bool vpCheckVersion(uint32_t actual, uint32_t expected) +{ + uint32_t actualMajor = VK_API_VERSION_MAJOR(actual); + uint32_t actualMinor = VK_API_VERSION_MINOR(actual); + uint32_t expectedMajor = VK_API_VERSION_MAJOR(expected); + uint32_t expectedMinor = VK_API_VERSION_MINOR(expected); + return actualMajor > expectedMajor || (actualMajor == expectedMajor && actualMinor >= expectedMinor); } -VPAPI_ATTR bool HasExtension(const std::vector& list, const VkExtensionProperties& element) { - for (std::size_t i = 0, n = list.size(); i < n; ++i) { - if (strcmp(list[i].extensionName, element.extensionName) == 0) { - return true; - } - } - - return false; +VPAPI_ATTR bool HasExtension(const std::vector &list, const VkExtensionProperties &element) +{ + for (std::size_t i = 0, n = list.size(); i < n; ++i) + { + if (strcmp(list[i].extensionName, element.extensionName) == 0) + { + return true; + } + } + + return false; } -VPAPI_ATTR bool CheckExtension(const VkExtensionProperties* supportedProperties, size_t supportedSize, const char *requestedExtension) { - bool found = false; - for (size_t i = 0, n = supportedSize; i < n; ++i) { - if (strcmp(supportedProperties[i].extensionName, requestedExtension) == 0) { - found = true; - break; - // Drivers don't actually update their spec version, so we cannot rely on this - // if (supportedProperties[i].specVersion >= expectedVersion) found = true; - } - } - return found; +VPAPI_ATTR bool CheckExtension(const VkExtensionProperties *supportedProperties, size_t supportedSize, const char *requestedExtension) +{ + bool found = false; + for (size_t i = 0, n = supportedSize; i < n; ++i) + { + if (strcmp(supportedProperties[i].extensionName, requestedExtension) == 0) + { + found = true; + break; + // Drivers don't actually update their spec version, so we cannot rely on this + // if (supportedProperties[i].specVersion >= expectedVersion) found = true; + } + } + VP_DEBUG_COND_MSGF(!found, "Unsupported extension: %s", requestedExtension); + return found; } -VPAPI_ATTR bool CheckExtension(const std::vector& extensions, const char* extension) { - for (const char* c : extensions) { - if (strcmp(c, extension) == 0) { - return true; - } - } - return false; +VPAPI_ATTR bool CheckExtension(const std::vector &extensions, const char *extension) +{ + for (const char *c : extensions) + { + if (strcmp(c, extension) == 0) + { + return true; + } + } + return false; } -VPAPI_ATTR void GetExtensions(uint32_t extensionCount, const VkExtensionProperties *pExtensions, std::vector &extensions) { - for (uint32_t ext_index = 0; ext_index < extensionCount; ++ext_index) { - if (CheckExtension(extensions, pExtensions[ext_index].extensionName)) { - continue; - } - extensions.push_back(pExtensions[ext_index].extensionName); - } +VPAPI_ATTR void GetExtensions(uint32_t extensionCount, const VkExtensionProperties *pExtensions, std::vector &extensions) +{ + for (uint32_t ext_index = 0; ext_index < extensionCount; ++ext_index) + { + if (CheckExtension(extensions, pExtensions[ext_index].extensionName)) + { + continue; + } + extensions.push_back(pExtensions[ext_index].extensionName); + } } VPAPI_ATTR std::vector GatherBlocks( - uint32_t enabledFullProfileCount, const VpProfileProperties* pEnabledFullProfiles, - uint32_t enabledProfileBlockCount, const VpBlockProperties* pEnabledProfileBlocks) { - std::vector results; + uint32_t enabledFullProfileCount, const VpProfileProperties *pEnabledFullProfiles, + uint32_t enabledProfileBlockCount, const VpBlockProperties *pEnabledProfileBlocks) +{ + std::vector results; - for (std::size_t profile_index = 0; profile_index < enabledFullProfileCount; ++profile_index) { - const std::vector& gathered_profiles = GatherProfiles(pEnabledFullProfiles[profile_index]); + for (std::size_t profile_index = 0; profile_index < enabledFullProfileCount; ++profile_index) + { + const std::vector &gathered_profiles = GatherProfiles(pEnabledFullProfiles[profile_index]); - for (std::size_t gathered_index = 0; gathered_index < gathered_profiles.size(); ++gathered_index) { - VpBlockProperties block{gathered_profiles[gathered_index], 0, ""}; - results.push_back(block); - } - } + for (std::size_t gathered_index = 0; gathered_index < gathered_profiles.size(); ++gathered_index) + { + VpBlockProperties block{gathered_profiles[gathered_index], 0, ""}; + results.push_back(block); + } + } - for (std::size_t block_index = 0; block_index < enabledProfileBlockCount; ++block_index) { - results.push_back(pEnabledProfileBlocks[block_index]); - } + for (std::size_t block_index = 0; block_index < enabledProfileBlockCount; ++block_index) + { + results.push_back(pEnabledProfileBlocks[block_index]); + } - return results; + return results; } VPAPI_ATTR VkResult vpGetInstanceProfileSupportSingleProfile( - uint32_t api_version, - const std::vector& supported_extensions, - const VpProfileProperties* pProfile, - VkBool32* pSupported, - std::vector& supportedBlocks, - std::vector& unsupportedBlocks) { - assert(pProfile != nullptr); - - const detail::VpProfileDesc* pProfileDesc = vpGetProfileDesc(pProfile->profileName); - if (pProfileDesc == nullptr) { - *pSupported = VK_FALSE; - return VK_ERROR_UNKNOWN; - } - - VpBlockProperties block{*pProfile, api_version}; - - if (pProfileDesc->props.specVersion < pProfile->specVersion) { - *pSupported = VK_FALSE; - unsupportedBlocks.push_back(block); - } - - // Required API version is built in root profile, not need to check dependent profile API versions - if (api_version != 0) { - if (!vpCheckVersion(api_version, pProfileDesc->minApiVersion)) { - - *pSupported = VK_FALSE; - unsupportedBlocks.push_back(block); - } - } - - for (uint32_t capability_index = 0; capability_index < pProfileDesc->requiredCapabilityCount; ++capability_index) { - const VpCapabilitiesDesc& capabilities_desc = pProfileDesc->pRequiredCapabilities[capability_index]; - - VkBool32 supported_capabilities = VK_FALSE; - for (uint32_t variant_index = 0; variant_index < capabilities_desc.variantCount; ++variant_index) { - const VpVariantDesc& variant_desc = capabilities_desc.pVariants[variant_index]; - - VkBool32 supported_variant = VK_TRUE; - for (uint32_t i = 0; i < variant_desc.instanceExtensionCount; ++i) { - if (!detail::CheckExtension(supported_extensions.data(), supported_extensions.size(), - variant_desc.pInstanceExtensions[i].extensionName)) { - supported_variant = VK_FALSE; - memcpy(block.blockName, variant_desc.blockName, VP_MAX_PROFILE_NAME_SIZE * sizeof(char)); - unsupportedBlocks.push_back(block); - } - } - - if (supported_variant == VK_TRUE) { - supported_capabilities = VK_TRUE; - memcpy(block.blockName, variant_desc.blockName, VP_MAX_PROFILE_NAME_SIZE * sizeof(char)); - supportedBlocks.push_back(block); - } - } - - if (supported_capabilities == VK_FALSE) { - *pSupported = VK_FALSE; - return VK_SUCCESS; - } - } - - return VK_SUCCESS; + uint32_t api_version, + const std::vector &supported_extensions, + const VpProfileProperties *pProfile, + VkBool32 *pSupported, + std::vector &supportedBlocks, + std::vector &unsupportedBlocks) +{ + assert(pProfile != nullptr); + + const detail::VpProfileDesc *pProfileDesc = vpGetProfileDesc(pProfile->profileName); + if (pProfileDesc == nullptr) + { + *pSupported = VK_FALSE; + return VK_ERROR_UNKNOWN; + } + + VpBlockProperties block{*pProfile, api_version}; + + if (pProfileDesc->props.specVersion < pProfile->specVersion) + { + *pSupported = VK_FALSE; + unsupportedBlocks.push_back(block); + } + + // Required API version is built in root profile, not need to check dependent profile API versions + if (api_version != 0) + { + if (!vpCheckVersion(api_version, pProfileDesc->minApiVersion)) + { + VP_DEBUG_MSGF("Unsupported Profile API version %u.%u.%u on a Vulkan system with version %u.%u.%u", VK_API_VERSION_MAJOR(pProfileDesc->minApiVersion), VK_API_VERSION_MINOR(pProfileDesc->minApiVersion), VK_API_VERSION_PATCH(pProfileDesc->minApiVersion), VK_API_VERSION_MAJOR(api_version), VK_API_VERSION_MINOR(api_version), VK_API_VERSION_PATCH(api_version)); + + *pSupported = VK_FALSE; + unsupportedBlocks.push_back(block); + } + } + + for (uint32_t capability_index = 0; capability_index < pProfileDesc->requiredCapabilityCount; ++capability_index) + { + const VpCapabilitiesDesc &capabilities_desc = pProfileDesc->pRequiredCapabilities[capability_index]; + + VkBool32 supported_capabilities = VK_FALSE; + for (uint32_t variant_index = 0; variant_index < capabilities_desc.variantCount; ++variant_index) + { + const VpVariantDesc &variant_desc = capabilities_desc.pVariants[variant_index]; + + VkBool32 supported_variant = VK_TRUE; + for (uint32_t i = 0; i < variant_desc.instanceExtensionCount; ++i) + { + if (!detail::CheckExtension(supported_extensions.data(), supported_extensions.size(), + variant_desc.pInstanceExtensions[i].extensionName)) + { + supported_variant = VK_FALSE; + memcpy(block.blockName, variant_desc.blockName, VP_MAX_PROFILE_NAME_SIZE * sizeof(char)); + unsupportedBlocks.push_back(block); + } + } + + if (supported_variant == VK_TRUE) + { + supported_capabilities = VK_TRUE; + memcpy(block.blockName, variant_desc.blockName, VP_MAX_PROFILE_NAME_SIZE * sizeof(char)); + supportedBlocks.push_back(block); + } + } + + if (supported_capabilities == VK_FALSE) + { + *pSupported = VK_FALSE; + return VK_SUCCESS; + } + } + + return VK_SUCCESS; } -enum structure_type { - STRUCTURE_FEATURE = 0, - STRUCTURE_PROPERTY, - STRUCTURE_FORMAT +enum structure_type +{ + STRUCTURE_FEATURE = 0, + STRUCTURE_PROPERTY, + STRUCTURE_QUEUE_FAMILY, + STRUCTURE_FORMAT }; VPAPI_ATTR VkResult vpGetProfileStructureTypes( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - structure_type type, - uint32_t* pStructureTypeCount, - VkStructureType* pStructureTypes) { + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + structure_type type, + uint32_t *pStructureTypeCount, + VkStructureType *pStructureTypes) +{ #ifdef VP_USE_OBJECT - (void)capabilities; -#endif//VP_USE_OBJECT - - VkResult result = pBlockName == nullptr ? VK_SUCCESS : VK_INCOMPLETE; - - std::vector results; - - const std::vector& gathered_profiles = detail::GatherProfiles(*pProfile); - - for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) { - const detail::VpProfileDesc* profile_desc = detail::vpGetProfileDesc(gathered_profiles[profile_index].profileName); - if (profile_desc == nullptr) return VK_ERROR_UNKNOWN; - - for (uint32_t capability_index = 0; capability_index < profile_desc->requiredCapabilityCount; ++capability_index) { - const detail::VpCapabilitiesDesc& cap_desc = profile_desc->pRequiredCapabilities[capability_index]; - - for (uint32_t variant_index = 0; variant_index < cap_desc.variantCount; ++variant_index) { - const detail::VpVariantDesc& variant = cap_desc.pVariants[variant_index]; - if (pBlockName != nullptr) { - if (strcmp(variant.blockName, pBlockName) != 0) { - continue; - } - result = VK_SUCCESS; - } - - uint32_t count = 0; - const VkStructureType* data = nullptr; - - switch (type) { - default: - case STRUCTURE_FEATURE: - count = variant.featureStructTypeCount; - data = variant.pFeatureStructTypes; - break; - case STRUCTURE_PROPERTY: - count = variant.propertyStructTypeCount; - data = variant.pPropertyStructTypes; - break; - case STRUCTURE_FORMAT: - count = variant.formatStructTypeCount; - data = variant.pFormatStructTypes; - break; - } - - for (uint32_t type_index = 0; type_index < count; ++type_index) { - const VkStructureType dataType = data[type_index]; - if (std::find(results.begin(), results.end(), dataType) == std::end(results)) { - results.push_back(dataType); - } - } - } - } - } - - const uint32_t count = static_cast(results.size()); - std::sort(results.begin(), results.end()); - - if (pStructureTypes == nullptr) { - *pStructureTypeCount = count; - } else { - if (*pStructureTypeCount < count) { - result = VK_INCOMPLETE; - } else { - *pStructureTypeCount = count; - } - - if (*pStructureTypeCount > 0) { - memcpy(pStructureTypes, &results[0], *pStructureTypeCount * sizeof(VkStructureType)); - } - } - - return result; + (void) capabilities; +#endif // VP_USE_OBJECT + + VkResult result = pBlockName == nullptr ? VK_SUCCESS : VK_INCOMPLETE; + + std::vector results; + + const std::vector &gathered_profiles = detail::GatherProfiles(*pProfile); + + for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) + { + const detail::VpProfileDesc *profile_desc = detail::vpGetProfileDesc(gathered_profiles[profile_index].profileName); + if (profile_desc == nullptr) + return VK_ERROR_UNKNOWN; + + for (uint32_t capability_index = 0; capability_index < profile_desc->requiredCapabilityCount; ++capability_index) + { + const detail::VpCapabilitiesDesc &cap_desc = profile_desc->pRequiredCapabilities[capability_index]; + + for (uint32_t variant_index = 0; variant_index < cap_desc.variantCount; ++variant_index) + { + const detail::VpVariantDesc &variant = cap_desc.pVariants[variant_index]; + if (pBlockName != nullptr) + { + if (strcmp(variant.blockName, pBlockName) != 0) + { + continue; + } + result = VK_SUCCESS; + } + + uint32_t count = 0; + const VkStructureType *data = nullptr; + + switch (type) + { + default: + case STRUCTURE_FEATURE: + count = variant.featureStructTypeCount; + data = variant.pFeatureStructTypes; + break; + case STRUCTURE_PROPERTY: + count = variant.propertyStructTypeCount; + data = variant.pPropertyStructTypes; + break; + case STRUCTURE_QUEUE_FAMILY: + count = variant.queueFamilyStructTypeCount; + data = variant.pQueueFamilyStructTypes; + break; + case STRUCTURE_FORMAT: + count = variant.formatStructTypeCount; + data = variant.pFormatStructTypes; + break; + } + + for (uint32_t type_index = 0; type_index < count; ++type_index) + { + const VkStructureType dataType = data[type_index]; + if (std::find(results.begin(), results.end(), dataType) == std::end(results)) + { + results.push_back(dataType); + } + } + } + } + } + + const uint32_t count = static_cast(results.size()); + std::sort(results.begin(), results.end()); + + if (pStructureTypes == nullptr) + { + *pStructureTypeCount = count; + } + else + { + if (*pStructureTypeCount < count) + { + result = VK_INCOMPLETE; + } + else + { + *pStructureTypeCount = count; + } + + if (*pStructureTypeCount > 0) + { + memcpy(pStructureTypes, &results[0], *pStructureTypeCount * sizeof(VkStructureType)); + } + } + + return result; } -enum ExtensionType { - EXTENSION_INSTANCE, - EXTENSION_DEVICE, +enum ExtensionType +{ + EXTENSION_INSTANCE, + EXTENSION_DEVICE, }; VPAPI_ATTR VkResult vpGetProfileExtensionProperties( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - ExtensionType type, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties) { + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + ExtensionType type, + uint32_t *pPropertyCount, + VkExtensionProperties *pProperties) +{ #ifdef VP_USE_OBJECT - (void)capabilities; -#endif//VP_USE_OBJECT - - VkResult result = pBlockName == nullptr ? VK_SUCCESS : VK_INCOMPLETE; - - std::vector results; - - const std::vector& gathered_profiles = detail::GatherProfiles(*pProfile, pBlockName); - - for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) { - const detail::VpProfileDesc* profile_desc = detail::vpGetProfileDesc(gathered_profiles[profile_index].profileName); - if (profile_desc == nullptr) { - return VK_ERROR_UNKNOWN; - } - - for (uint32_t capability_index = 0; capability_index < profile_desc->requiredCapabilityCount; ++capability_index) { - const detail::VpCapabilitiesDesc& cap_desc = profile_desc->pRequiredCapabilities[capability_index]; - - for (uint32_t variant_index = 0; variant_index < cap_desc.variantCount; ++variant_index) { - const detail::VpVariantDesc& variant = cap_desc.pVariants[variant_index]; - if (pBlockName != nullptr) { - if (strcmp(variant.blockName, pBlockName) != 0) { - continue; - } - result = VK_SUCCESS; - } - - switch (type) { - default: - case EXTENSION_INSTANCE: - for (uint32_t ext_index = 0; ext_index < variant.instanceExtensionCount; ++ext_index) { - if (detail::HasExtension(results, variant.pInstanceExtensions[ext_index])) { - continue; - } - results.push_back(variant.pInstanceExtensions[ext_index]); - } - break; - case EXTENSION_DEVICE: - for (uint32_t ext_index = 0; ext_index < variant.deviceExtensionCount; ++ext_index) { - if (detail::HasExtension(results, variant.pDeviceExtensions[ext_index])) { - continue; - } - results.push_back(variant.pDeviceExtensions[ext_index]); - } - break; - } - } - } - } - - const uint32_t count = static_cast(results.size()); - - if (pProperties == nullptr) { - *pPropertyCount = count; - } else { - if (*pPropertyCount < count) { - result = VK_INCOMPLETE; - } else { - *pPropertyCount = count; - } - if (*pPropertyCount > 0) { - memcpy(pProperties, &results[0], *pPropertyCount * sizeof(VkExtensionProperties)); - } - } - - return result; + (void) capabilities; +#endif // VP_USE_OBJECT + + VkResult result = pBlockName == nullptr ? VK_SUCCESS : VK_INCOMPLETE; + + std::vector results; + + const std::vector &gathered_profiles = detail::GatherProfiles(*pProfile, pBlockName); + + for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) + { + const detail::VpProfileDesc *profile_desc = detail::vpGetProfileDesc(gathered_profiles[profile_index].profileName); + if (profile_desc == nullptr) + { + return VK_ERROR_UNKNOWN; + } + + for (uint32_t capability_index = 0; capability_index < profile_desc->requiredCapabilityCount; ++capability_index) + { + const detail::VpCapabilitiesDesc &cap_desc = profile_desc->pRequiredCapabilities[capability_index]; + + for (uint32_t variant_index = 0; variant_index < cap_desc.variantCount; ++variant_index) + { + const detail::VpVariantDesc &variant = cap_desc.pVariants[variant_index]; + if (pBlockName != nullptr) + { + if (strcmp(variant.blockName, pBlockName) != 0) + { + continue; + } + result = VK_SUCCESS; + } + + switch (type) + { + default: + case EXTENSION_INSTANCE: + for (uint32_t ext_index = 0; ext_index < variant.instanceExtensionCount; ++ext_index) + { + if (detail::HasExtension(results, variant.pInstanceExtensions[ext_index])) + { + continue; + } + results.push_back(variant.pInstanceExtensions[ext_index]); + } + break; + case EXTENSION_DEVICE: + for (uint32_t ext_index = 0; ext_index < variant.deviceExtensionCount; ++ext_index) + { + if (detail::HasExtension(results, variant.pDeviceExtensions[ext_index])) + { + continue; + } + results.push_back(variant.pDeviceExtensions[ext_index]); + } + break; + } + } + } + } + + const uint32_t count = static_cast(results.size()); + + if (pProperties == nullptr) + { + *pPropertyCount = count; + } + else + { + if (*pPropertyCount < count) + { + result = VK_INCOMPLETE; + } + else + { + *pPropertyCount = count; + } + if (*pPropertyCount > 0) + { + memcpy(pProperties, &results[0], *pPropertyCount * sizeof(VkExtensionProperties)); + } + } + + return result; } -} // namespace detail - -struct VpCapabilities_T : public VpVulkanFunctions { - bool singleton = false; - uint32_t apiVersion = VK_API_VERSION_1_0; - - static VpCapabilities_T& Get() { - static VpCapabilities_T instance; - VpCapabilitiesCreateInfo createInfo{}; - createInfo.flags = VP_PROFILE_CREATE_STATIC_BIT; - instance.init(&createInfo); - instance.singleton = true; - return instance; - } - - VpCapabilities_T() { - this->GetInstanceProcAddr = nullptr; - this->GetDeviceProcAddr = nullptr; - this->EnumerateInstanceVersion = nullptr; - this->EnumerateInstanceExtensionProperties = nullptr; - this->EnumerateDeviceExtensionProperties = nullptr; - this->GetPhysicalDeviceFeatures2 = nullptr; - this->GetPhysicalDeviceProperties2 = nullptr; - this->GetPhysicalDeviceFormatProperties2 = nullptr; - this->GetPhysicalDeviceQueueFamilyProperties2 = nullptr; - this->CreateInstance = nullptr; - this->CreateDevice = nullptr; - } - - VkResult init(const VpCapabilitiesCreateInfo* pCreateInfo) { - assert(pCreateInfo != nullptr); - - return ImportVulkanFunctions(pCreateInfo); - } - - VkResult ImportVulkanFunctions(const VpCapabilitiesCreateInfo* pCreateInfo) { - if (pCreateInfo->flags & VP_PROFILE_CREATE_STATIC_BIT) { - ImportVulkanFunctions_Static(); - } - - if (pCreateInfo->pVulkanFunctions != nullptr) { - ImportVulkanFunctions_Custom((VpVulkanFunctions*)pCreateInfo->pVulkanFunctions); - } -/* - if (pCreateInfo->flags & VP_PROFILE_CREATE_DYNAMIC_BIT) { - ImportVulkanFunctions_Dynamic(); - } -*/ - return ValidateVulkanFunctions(); - } - - void ImportVulkanFunctions_Static() { - // Vulkan 1.1 - this->GetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)vkGetInstanceProcAddr; - this->GetDeviceProcAddr = (PFN_vkGetDeviceProcAddr)vkGetDeviceProcAddr; - - this->EnumerateInstanceVersion = (PFN_vkEnumerateInstanceVersion)vkEnumerateInstanceVersion; - this->EnumerateInstanceExtensionProperties = (PFN_vkEnumerateInstanceExtensionProperties)vkEnumerateInstanceExtensionProperties; - this->EnumerateDeviceExtensionProperties = (PFN_vkEnumerateDeviceExtensionProperties)vkEnumerateDeviceExtensionProperties; - - this->GetPhysicalDeviceFeatures2 = (PFN_vkGetPhysicalDeviceFeatures2)vkGetPhysicalDeviceFeatures2; - this->GetPhysicalDeviceProperties2 = (PFN_vkGetPhysicalDeviceProperties2)vkGetPhysicalDeviceProperties2; - this->GetPhysicalDeviceFormatProperties2 = (PFN_vkGetPhysicalDeviceFormatProperties2)vkGetPhysicalDeviceFormatProperties2; - this->GetPhysicalDeviceQueueFamilyProperties2 = (PFN_vkGetPhysicalDeviceQueueFamilyProperties2)vkGetPhysicalDeviceQueueFamilyProperties2; - - this->CreateInstance = (PFN_vkCreateInstance)vkCreateInstance; - this->CreateDevice = (PFN_vkCreateDevice)vkCreateDevice; - } - - void ImportVulkanFunctions_Custom(VpVulkanFunctions* pFunctions) { - #define VP_COPY_IF_NOT_NULL(funcName) if(pFunctions->funcName != nullptr) this->funcName = pFunctions->funcName; - - VP_COPY_IF_NOT_NULL(GetInstanceProcAddr); - VP_COPY_IF_NOT_NULL(GetDeviceProcAddr); - - VP_COPY_IF_NOT_NULL(EnumerateInstanceVersion); - VP_COPY_IF_NOT_NULL(EnumerateInstanceExtensionProperties); - VP_COPY_IF_NOT_NULL(EnumerateDeviceExtensionProperties); - - VP_COPY_IF_NOT_NULL(GetPhysicalDeviceFeatures2); - VP_COPY_IF_NOT_NULL(GetPhysicalDeviceProperties2); - VP_COPY_IF_NOT_NULL(GetPhysicalDeviceFormatProperties2); - VP_COPY_IF_NOT_NULL(GetPhysicalDeviceQueueFamilyProperties2); - - VP_COPY_IF_NOT_NULL(CreateInstance); - VP_COPY_IF_NOT_NULL(CreateDevice); - #undef VP_COPY_IF_NOT_NULL - } -/* - VkResult ImportVulkanFunctions_Dynamic() { - // To use VP_PROFILE_CREATE_DYNAMIC_BIT you have to pass VpVulkanFunctions::vkGetInstanceProcAddr and vkGetDeviceProcAddr as VpCapabilitiesCreateInfo::pVulkanFunctions. Other members can be null. - if (this->GetInstanceProcAddr == nullptr || this->GetDeviceProcAddr == nullptr) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - #define VP_FETCH_INSTANCE_FUNC(memberName, functionNameString) if(this->memberName == nullptr) this->memberName = (PFN_vk##memberName)this->GetInstanceProcAddr(m_hInstance, functionNameString); - #define VP_FETCH_DEVICE_FUNC(memberName, functionNameString) if(this->memberName == nullptr) this->memberName = (PFN_vk##memberName)this->GetDeviceProcAddr(m_hDevice, functionNameString); - - VP_FETCH_INSTANCE_FUNC(GetInstanceProcAddr, "vkGetInstanceProcAddr"); - VP_FETCH_DEVICE_FUNC(GetDeviceProcAddr, "vkGetDeviceProcAddr"); - - VP_FETCH_INSTANCE_FUNC(EnumerateInstanceVersion, "vkEnumerateInstanceVersion"); - VP_FETCH_INSTANCE_FUNC(EnumerateInstanceExtensionProperties, "vkEnumerateInstanceExtensionProperties"); - VP_FETCH_DEVICE_FUNC(EnumerateDeviceExtensionProperties, "vkEnumerateDeviceExtensionProperties"); - - VP_FETCH_DEVICE_FUNC(GetPhysicalDeviceFeatures2, "vkGetPhysicalDeviceFeatures2"); - VP_FETCH_DEVICE_FUNC(GetPhysicalDeviceProperties2, "vkGetPhysicalDeviceProperties2"); - VP_FETCH_DEVICE_FUNC(GetPhysicalDeviceFormatProperties2, "vkGetPhysicalDeviceFormatProperties2"); - VP_FETCH_DEVICE_FUNC(GetPhysicalDeviceQueueFamilyProperties2, "vkGetPhysicalDeviceQueueFamilyProperties2"); - - VP_FETCH_INSTANCE_FUNC(CreateInstance, "vkCreateInstance"); - VP_FETCH_DEVICE_FUNC(CreateDevice, "vkCreateDevice"); - #undef VP_FETCH_DEVICE_FUNC - #undef VP_FETCH_INSTANCE_FUNC - } -*/ - VkResult ValidateVulkanFunctions() { - if (this->GetInstanceProcAddr == nullptr) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - if (this->GetDeviceProcAddr == nullptr) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - if (this->EnumerateInstanceVersion == nullptr && apiVersion >= VK_API_VERSION_1_1) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - if (this->EnumerateInstanceExtensionProperties == nullptr) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - if (this->EnumerateDeviceExtensionProperties == nullptr) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - if (this->GetPhysicalDeviceFeatures2 == nullptr) { - return apiVersion >= VK_API_VERSION_1_1 ? VK_ERROR_INITIALIZATION_FAILED : VK_ERROR_EXTENSION_NOT_PRESENT; - } - - if (this->GetPhysicalDeviceProperties2 == nullptr) { - return apiVersion >= VK_API_VERSION_1_1 ? VK_ERROR_INITIALIZATION_FAILED : VK_ERROR_EXTENSION_NOT_PRESENT; - } - - if (this->GetPhysicalDeviceFormatProperties2 == nullptr) { - return apiVersion >= VK_API_VERSION_1_1 ? VK_ERROR_INITIALIZATION_FAILED : VK_ERROR_EXTENSION_NOT_PRESENT; - } - - if (this->GetPhysicalDeviceQueueFamilyProperties2 == nullptr) { - return apiVersion >= VK_API_VERSION_1_1 ? VK_ERROR_INITIALIZATION_FAILED : VK_ERROR_EXTENSION_NOT_PRESENT; - } - - if (this->CreateInstance == nullptr) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - if (this->CreateDevice == nullptr) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - return VK_SUCCESS; - } +VPAPI_ATTR VkResult vpGetProfileVideoProfileDesc( + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t videoProfileIndex, + const detail::VpVideoProfileDesc **ppVideoProfileDesc) +{ + VkResult result = pBlockName == nullptr ? VK_SUCCESS : VK_INCOMPLETE; + + uint32_t curr_base_video_profile_index = 0; + + const std::vector &gathered_profiles = detail::GatherProfiles(*pProfile); + + for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) + { + const detail::VpProfileDesc *profile_desc = detail::vpGetProfileDesc(gathered_profiles[profile_index].profileName); + if (profile_desc == nullptr) + return VK_ERROR_UNKNOWN; + + for (uint32_t capability_index = 0; capability_index < profile_desc->requiredCapabilityCount; ++capability_index) + { + const detail::VpCapabilitiesDesc &cap_desc = profile_desc->pRequiredCapabilities[capability_index]; + + for (uint32_t variant_index = 0; variant_index < cap_desc.variantCount; ++variant_index) + { + const detail::VpVariantDesc &variant = cap_desc.pVariants[variant_index]; + if (pBlockName != nullptr) + { + if (strcmp(variant.blockName, pBlockName) != 0) + { + continue; + } + result = VK_SUCCESS; + } + + if (videoProfileIndex < curr_base_video_profile_index + variant.videoProfileCount) + { + *ppVideoProfileDesc = &variant.pVideoProfiles[videoProfileIndex - curr_base_video_profile_index]; + return result; + } + else + { + curr_base_video_profile_index += variant.videoProfileCount; + } + } + } + } + + *ppVideoProfileDesc = nullptr; + return VK_ERROR_UNKNOWN; +} + +} // namespace detail + +struct VpCapabilities_T : public VpVulkanFunctions +{ + bool singleton = false; + uint32_t apiVersion = VK_API_VERSION_1_0; + + static VpCapabilities_T &Get() + { + static VpCapabilities_T instance; + VpCapabilitiesCreateInfo createInfo{}; + createInfo.flags = VP_PROFILE_CREATE_STATIC_BIT; + instance.init(&createInfo); + instance.singleton = true; + return instance; + } + + VpCapabilities_T() + { + this->GetInstanceProcAddr = nullptr; + this->GetDeviceProcAddr = nullptr; + this->EnumerateInstanceVersion = nullptr; + this->EnumerateInstanceExtensionProperties = nullptr; + this->EnumerateDeviceExtensionProperties = nullptr; + this->GetPhysicalDeviceFeatures2 = nullptr; + this->GetPhysicalDeviceProperties2 = nullptr; + this->GetPhysicalDeviceFormatProperties2 = nullptr; + this->GetPhysicalDeviceQueueFamilyProperties2 = nullptr; + this->CreateInstance = nullptr; + this->CreateDevice = nullptr; + } + + VkResult init(const VpCapabilitiesCreateInfo *pCreateInfo) + { + assert(pCreateInfo != nullptr); + + return ImportVulkanFunctions(pCreateInfo); + } + + VkResult ImportVulkanFunctions(const VpCapabilitiesCreateInfo *pCreateInfo) + { + if (pCreateInfo->flags & VP_PROFILE_CREATE_STATIC_BIT) + { + ImportVulkanFunctions_Static(); + } + + if (pCreateInfo->pVulkanFunctions != nullptr) + { + ImportVulkanFunctions_Custom((VpVulkanFunctions *) pCreateInfo->pVulkanFunctions); + } + /* + if (pCreateInfo->flags & VP_PROFILE_CREATE_DYNAMIC_BIT) { + ImportVulkanFunctions_Dynamic(); + } + */ + return ValidateVulkanFunctions(); + } + + void ImportVulkanFunctions_Static() + { + // Vulkan 1.1 + this->GetInstanceProcAddr = (PFN_vkGetInstanceProcAddr) vkGetInstanceProcAddr; + this->GetDeviceProcAddr = (PFN_vkGetDeviceProcAddr) vkGetDeviceProcAddr; + + this->EnumerateInstanceVersion = (PFN_vkEnumerateInstanceVersion) vkEnumerateInstanceVersion; + this->EnumerateInstanceExtensionProperties = (PFN_vkEnumerateInstanceExtensionProperties) vkEnumerateInstanceExtensionProperties; + this->EnumerateDeviceExtensionProperties = (PFN_vkEnumerateDeviceExtensionProperties) vkEnumerateDeviceExtensionProperties; + + this->GetPhysicalDeviceFeatures2 = (PFN_vkGetPhysicalDeviceFeatures2) vkGetPhysicalDeviceFeatures2; + this->GetPhysicalDeviceProperties2 = (PFN_vkGetPhysicalDeviceProperties2) vkGetPhysicalDeviceProperties2; + this->GetPhysicalDeviceFormatProperties2 = (PFN_vkGetPhysicalDeviceFormatProperties2) vkGetPhysicalDeviceFormatProperties2; + this->GetPhysicalDeviceQueueFamilyProperties2 = (PFN_vkGetPhysicalDeviceQueueFamilyProperties2) vkGetPhysicalDeviceQueueFamilyProperties2; + + this->CreateInstance = (PFN_vkCreateInstance) vkCreateInstance; + this->CreateDevice = (PFN_vkCreateDevice) vkCreateDevice; + } + + void ImportVulkanFunctions_Custom(VpVulkanFunctions *pFunctions) + { +#define VP_COPY_IF_NOT_NULL(funcName) \ + if (pFunctions->funcName != nullptr) \ + this->funcName = pFunctions->funcName; + + VP_COPY_IF_NOT_NULL(GetInstanceProcAddr); + VP_COPY_IF_NOT_NULL(GetDeviceProcAddr); + + VP_COPY_IF_NOT_NULL(EnumerateInstanceVersion); + VP_COPY_IF_NOT_NULL(EnumerateInstanceExtensionProperties); + VP_COPY_IF_NOT_NULL(EnumerateDeviceExtensionProperties); + + VP_COPY_IF_NOT_NULL(GetPhysicalDeviceFeatures2); + VP_COPY_IF_NOT_NULL(GetPhysicalDeviceProperties2); + VP_COPY_IF_NOT_NULL(GetPhysicalDeviceFormatProperties2); + VP_COPY_IF_NOT_NULL(GetPhysicalDeviceQueueFamilyProperties2); + + VP_COPY_IF_NOT_NULL(CreateInstance); + VP_COPY_IF_NOT_NULL(CreateDevice); +#undef VP_COPY_IF_NOT_NULL + } + /* + VkResult ImportVulkanFunctions_Dynamic() { + // To use VP_PROFILE_CREATE_DYNAMIC_BIT you have to pass VpVulkanFunctions::vkGetInstanceProcAddr and vkGetDeviceProcAddr as VpCapabilitiesCreateInfo::pVulkanFunctions. Other members can be null. + if (this->GetInstanceProcAddr == nullptr || this->GetDeviceProcAddr == nullptr) { + return VK_ERROR_INITIALIZATION_FAILED; + } + + #define VP_FETCH_INSTANCE_FUNC(memberName, functionNameString) if(this->memberName == nullptr) this->memberName = (PFN_vk##memberName)this->GetInstanceProcAddr(m_hInstance, functionNameString); + #define VP_FETCH_DEVICE_FUNC(memberName, functionNameString) if(this->memberName == nullptr) this->memberName = (PFN_vk##memberName)this->GetDeviceProcAddr(m_hDevice, functionNameString); + + VP_FETCH_INSTANCE_FUNC(GetInstanceProcAddr, "vkGetInstanceProcAddr"); + VP_FETCH_DEVICE_FUNC(GetDeviceProcAddr, "vkGetDeviceProcAddr"); + + VP_FETCH_INSTANCE_FUNC(EnumerateInstanceVersion, "vkEnumerateInstanceVersion"); + VP_FETCH_INSTANCE_FUNC(EnumerateInstanceExtensionProperties, "vkEnumerateInstanceExtensionProperties"); + VP_FETCH_DEVICE_FUNC(EnumerateDeviceExtensionProperties, "vkEnumerateDeviceExtensionProperties"); + + VP_FETCH_DEVICE_FUNC(GetPhysicalDeviceFeatures2, "vkGetPhysicalDeviceFeatures2"); + VP_FETCH_DEVICE_FUNC(GetPhysicalDeviceProperties2, "vkGetPhysicalDeviceProperties2"); + VP_FETCH_DEVICE_FUNC(GetPhysicalDeviceFormatProperties2, "vkGetPhysicalDeviceFormatProperties2"); + VP_FETCH_DEVICE_FUNC(GetPhysicalDeviceQueueFamilyProperties2, "vkGetPhysicalDeviceQueueFamilyProperties2"); + + VP_FETCH_INSTANCE_FUNC(CreateInstance, "vkCreateInstance"); + VP_FETCH_DEVICE_FUNC(CreateDevice, "vkCreateDevice"); + #undef VP_FETCH_DEVICE_FUNC + #undef VP_FETCH_INSTANCE_FUNC + } + */ + VkResult ValidateVulkanFunctions() + { + if (this->GetInstanceProcAddr == nullptr) + { + return VK_ERROR_INITIALIZATION_FAILED; + } + + if (this->GetDeviceProcAddr == nullptr) + { + return VK_ERROR_INITIALIZATION_FAILED; + } + + if (this->EnumerateInstanceVersion == nullptr && apiVersion >= VK_API_VERSION_1_1) + { + return VK_ERROR_INITIALIZATION_FAILED; + } + + if (this->EnumerateInstanceExtensionProperties == nullptr) + { + return VK_ERROR_INITIALIZATION_FAILED; + } + + if (this->EnumerateDeviceExtensionProperties == nullptr) + { + return VK_ERROR_INITIALIZATION_FAILED; + } + + if (this->GetPhysicalDeviceFeatures2 == nullptr) + { + return apiVersion >= VK_API_VERSION_1_1 ? VK_ERROR_INITIALIZATION_FAILED : VK_ERROR_EXTENSION_NOT_PRESENT; + } + + if (this->GetPhysicalDeviceProperties2 == nullptr) + { + return apiVersion >= VK_API_VERSION_1_1 ? VK_ERROR_INITIALIZATION_FAILED : VK_ERROR_EXTENSION_NOT_PRESENT; + } + + if (this->GetPhysicalDeviceFormatProperties2 == nullptr) + { + return apiVersion >= VK_API_VERSION_1_1 ? VK_ERROR_INITIALIZATION_FAILED : VK_ERROR_EXTENSION_NOT_PRESENT; + } + + if (this->GetPhysicalDeviceQueueFamilyProperties2 == nullptr) + { + return apiVersion >= VK_API_VERSION_1_1 ? VK_ERROR_INITIALIZATION_FAILED : VK_ERROR_EXTENSION_NOT_PRESENT; + } + + if (this->CreateInstance == nullptr) + { + return VK_ERROR_INITIALIZATION_FAILED; + } + + if (this->CreateDevice == nullptr) + { + return VK_ERROR_INITIALIZATION_FAILED; + } + + return VK_SUCCESS; + } }; VPAPI_ATTR VkResult vpCreateCapabilities( - const VpCapabilitiesCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VpCapabilities* pCapabilities) { - (void)pAllocator; + const VpCapabilitiesCreateInfo *pCreateInfo, + const VkAllocationCallbacks *pAllocator, + VpCapabilities *pCapabilities) +{ + (void) pAllocator; - VpCapabilities_T* capabilities = new VpCapabilities_T(); - VkResult result = capabilities->init(pCreateInfo); - *pCapabilities = capabilities; + VpCapabilities_T *capabilities = new VpCapabilities_T(); + VkResult result = capabilities->init(pCreateInfo); + *pCapabilities = capabilities; - return result; + return result; } /// Destroys allocator object. VPAPI_ATTR void vpDestroyCapabilities( - VpCapabilities capabilities, - const VkAllocationCallbacks* pAllocator) { - (void)pAllocator; - - delete capabilities; + VpCapabilities capabilities, + const VkAllocationCallbacks *pAllocator) +{ + (void) pAllocator; + + delete capabilities; } VPAPI_ATTR VkResult vpGetProfiles( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - uint32_t* pPropertyCount, - VpProfileProperties* pProperties) { + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + uint32_t *pPropertyCount, + VpProfileProperties *pProperties) +{ #ifdef VP_USE_OBJECT - (void)capabilities; -#endif//VP_USE_OBJECT - - VkResult result = VK_SUCCESS; - - if (pProperties == nullptr) { - *pPropertyCount = detail::profileCount; - } else { - if (*pPropertyCount < detail::profileCount) { - result = VK_INCOMPLETE; - } else { - *pPropertyCount = detail::profileCount; - } - for (uint32_t property_index = 0; property_index < *pPropertyCount; ++property_index) { - pProperties[property_index] = detail::profiles[property_index].props; - } - } - return result; + (void) capabilities; +#endif // VP_USE_OBJECT + + VkResult result = VK_SUCCESS; + + if (pProperties == nullptr) + { + *pPropertyCount = detail::profileCount; + } + else + { + if (*pPropertyCount < detail::profileCount) + { + result = VK_INCOMPLETE; + } + else + { + *pPropertyCount = detail::profileCount; + } + for (uint32_t property_index = 0; property_index < *pPropertyCount; ++property_index) + { + pProperties[property_index] = detail::profiles[property_index].props; + } + } + return result; } VPAPI_ATTR VkResult vpGetProfileRequiredProfiles( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - uint32_t* pPropertyCount, - VpProfileProperties* pProperties) { + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + uint32_t *pPropertyCount, + VpProfileProperties *pProperties) +{ #ifdef VP_USE_OBJECT - (void)capabilities; -#endif//VP_USE_OBJECT - - VkResult result = VK_SUCCESS; - - const detail::VpProfileDesc* desc = detail::vpGetProfileDesc(pProfile->profileName); - if (desc == nullptr) { - return VK_ERROR_UNKNOWN; - } - - if (pProperties == nullptr) { - *pPropertyCount = desc->requiredProfileCount; - } else { - if (*pPropertyCount < desc->requiredProfileCount) { - result = VK_INCOMPLETE; - } else { - *pPropertyCount = desc->requiredProfileCount; - } - for (uint32_t property_index = 0; property_index < *pPropertyCount; ++property_index) { - pProperties[property_index] = desc->pRequiredProfiles[property_index]; - } - } - return result; + (void) capabilities; +#endif // VP_USE_OBJECT + + VkResult result = VK_SUCCESS; + + const detail::VpProfileDesc *desc = detail::vpGetProfileDesc(pProfile->profileName); + if (desc == nullptr) + { + return VK_ERROR_UNKNOWN; + } + + if (pProperties == nullptr) + { + *pPropertyCount = desc->requiredProfileCount; + } + else + { + if (*pPropertyCount < desc->requiredProfileCount) + { + result = VK_INCOMPLETE; + } + else + { + *pPropertyCount = desc->requiredProfileCount; + } + for (uint32_t property_index = 0; property_index < *pPropertyCount; ++property_index) + { + pProperties[property_index] = desc->pRequiredProfiles[property_index]; + } + } + return result; } VPAPI_ATTR uint32_t vpGetProfileAPIVersion( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile) { + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile) +{ #ifdef VP_USE_OBJECT - (void)capabilities; -#endif//VP_USE_OBJECT + (void) capabilities; +#endif // VP_USE_OBJECT - const std::vector& gathered_profiles = detail::GatherProfiles(*pProfile, nullptr); + const std::vector &gathered_profiles = detail::GatherProfiles(*pProfile, nullptr); - uint32_t major = 0; - uint32_t minor = 0; - uint32_t patch = 0; + uint32_t major = 0; + uint32_t minor = 0; + uint32_t patch = 0; - for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) { - const detail::VpProfileDesc* desc = detail::vpGetProfileDesc(gathered_profiles[profile_index].profileName); - if (desc == nullptr) { - return 0; - } + for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) + { + const detail::VpProfileDesc *desc = detail::vpGetProfileDesc(gathered_profiles[profile_index].profileName); + if (desc == nullptr) + { + return 0; + } - major = std::max(major, VK_API_VERSION_MAJOR(desc->minApiVersion)); - minor = std::max(minor, VK_API_VERSION_MINOR(desc->minApiVersion)); - patch = std::max(patch, VK_API_VERSION_PATCH(desc->minApiVersion)); - } + major = std::max(major, VK_API_VERSION_MAJOR(desc->minApiVersion)); + minor = std::max(minor, VK_API_VERSION_MINOR(desc->minApiVersion)); + patch = std::max(patch, VK_API_VERSION_PATCH(desc->minApiVersion)); + } - return VK_MAKE_API_VERSION(0, major, minor, patch); + return VK_MAKE_API_VERSION(0, major, minor, patch); } VPAPI_ATTR VkResult vpGetProfileFallbacks( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - uint32_t* pPropertyCount, - VpProfileProperties* pProperties) { + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + uint32_t *pPropertyCount, + VpProfileProperties *pProperties) +{ #ifdef VP_USE_OBJECT - (void)capabilities; -#endif//VP_USE_OBJECT - - VkResult result = VK_SUCCESS; - - const detail::VpProfileDesc* desc = detail::vpGetProfileDesc(pProfile->profileName); - if (desc == nullptr) { - return VK_ERROR_UNKNOWN; - } - - if (pProperties == nullptr) { - *pPropertyCount = desc->fallbackCount; - } else { - if (*pPropertyCount < desc->fallbackCount) { - result = VK_INCOMPLETE; - } else { - *pPropertyCount = desc->fallbackCount; - } - for (uint32_t i = 0; i < *pPropertyCount; ++i) { - pProperties[i] = desc->pFallbacks[i]; - } - } - return result; + (void) capabilities; +#endif // VP_USE_OBJECT + + VkResult result = VK_SUCCESS; + + const detail::VpProfileDesc *desc = detail::vpGetProfileDesc(pProfile->profileName); + if (desc == nullptr) + { + return VK_ERROR_UNKNOWN; + } + + if (pProperties == nullptr) + { + *pPropertyCount = desc->fallbackCount; + } + else + { + if (*pPropertyCount < desc->fallbackCount) + { + result = VK_INCOMPLETE; + } + else + { + *pPropertyCount = desc->fallbackCount; + } + for (uint32_t i = 0; i < *pPropertyCount; ++i) + { + pProperties[i] = desc->pFallbacks[i]; + } + } + return result; } VPAPI_ATTR VkResult vpHasMultipleVariantsProfile( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - VkBool32* pHasMultipleVariants) { + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + VkBool32 *pHasMultipleVariants) +{ #ifdef VP_USE_OBJECT - (void)capabilities; -#endif//VP_USE_OBJECT - - const std::vector& gathered_profiles = detail::GatherProfiles(*pProfile, nullptr); - - for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) { - const detail::VpProfileDesc* desc = detail::vpGetProfileDesc(gathered_profiles[profile_index].profileName); - if (desc == nullptr) { - return VK_ERROR_UNKNOWN; - } - - for (uint32_t caps_index = 0, caps_count = desc->requiredCapabilityCount; caps_index < caps_count; ++caps_index) { - if (desc->pRequiredCapabilities[caps_index].variantCount > 1) { - *pHasMultipleVariants = VK_TRUE; - return VK_SUCCESS; - } - } - } - - *pHasMultipleVariants = VK_FALSE; - return VK_SUCCESS; + (void) capabilities; +#endif // VP_USE_OBJECT + + const std::vector &gathered_profiles = detail::GatherProfiles(*pProfile, nullptr); + + for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) + { + const detail::VpProfileDesc *desc = detail::vpGetProfileDesc(gathered_profiles[profile_index].profileName); + if (desc == nullptr) + { + return VK_ERROR_UNKNOWN; + } + + for (uint32_t caps_index = 0, caps_count = desc->requiredCapabilityCount; caps_index < caps_count; ++caps_index) + { + if (desc->pRequiredCapabilities[caps_index].variantCount > 1) + { + *pHasMultipleVariants = VK_TRUE; + return VK_SUCCESS; + } + } + } + + *pHasMultipleVariants = VK_FALSE; + return VK_SUCCESS; } VPAPI_ATTR VkResult vpGetInstanceProfileVariantsSupport( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const char* pLayerName, - const VpProfileProperties* pProfile, - VkBool32* pSupported, - uint32_t* pPropertyCount, - VpBlockProperties* pProperties) { + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const char *pLayerName, + const VpProfileProperties *pProfile, + VkBool32 *pSupported, + uint32_t *pPropertyCount, + VpBlockProperties *pProperties) +{ #ifdef VP_USE_OBJECT - const VpCapabilities_T& vp = capabilities == nullptr ? VpCapabilities_T::Get() : *capabilities; + const VpCapabilities_T &vp = capabilities == nullptr ? VpCapabilities_T::Get() : *capabilities; #else - const VpCapabilities_T& vp = VpCapabilities_T::Get(); -#endif//VP_USE_OBJECT - - VkResult result = VK_SUCCESS; - - uint32_t api_version = VK_API_VERSION_1_0; - PFN_vkEnumerateInstanceVersion pfnEnumerateInstanceVersion = vp.singleton ? - (PFN_vkEnumerateInstanceVersion)vkGetInstanceProcAddr(VK_NULL_HANDLE, "vkEnumerateInstanceVersion") : vp.EnumerateInstanceVersion; - if (pfnEnumerateInstanceVersion != nullptr) { - result = pfnEnumerateInstanceVersion(&api_version); - if (result != VK_SUCCESS) { - *pSupported = VK_FALSE; - return result; - } /* else { - } */ - } - - uint32_t supported_instance_extension_count = 0; - result = vp.EnumerateInstanceExtensionProperties(pLayerName, &supported_instance_extension_count, nullptr); - if (result != VK_SUCCESS) { - *pSupported = VK_FALSE; - return result; - } - std::vector supported_instance_extensions; - if (supported_instance_extension_count > 0) { - supported_instance_extensions.resize(supported_instance_extension_count); - } - result = vp.EnumerateInstanceExtensionProperties(pLayerName, &supported_instance_extension_count, supported_instance_extensions.data()); - if (result != VK_SUCCESS) { - *pSupported = VK_FALSE; - return result; - } - - VkBool32 supported = VK_TRUE; - - // We require VK_KHR_get_physical_device_properties2 if we are on Vulkan 1.0 - if (api_version < VK_API_VERSION_1_1) { - bool foundGPDP2 = false; - for (size_t ext_index = 0, ext_count = supported_instance_extensions.size(); ext_index < ext_count; ++ext_index) { - if (strcmp(supported_instance_extensions[ext_index].extensionName, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME) == 0) { - foundGPDP2 = true; - break; - } - } - if (!foundGPDP2) { - supported = VK_FALSE; - } - } - - const detail::VpProfileDesc* pProfileDesc = detail::vpGetProfileDesc(pProfile->profileName); - if (pProfileDesc == nullptr) return VK_ERROR_UNKNOWN; - - std::vector supported_blocks; - std::vector unsupported_blocks; - - result = detail::vpGetInstanceProfileSupportSingleProfile(api_version, supported_instance_extensions, pProfile, &supported, supported_blocks, unsupported_blocks); - if (result != VK_SUCCESS) { - *pSupported = supported; - return result; - } - - for (std::size_t required_profile_index = 0; required_profile_index < pProfileDesc->requiredProfileCount; ++required_profile_index) { - result = detail::vpGetInstanceProfileSupportSingleProfile(0, supported_instance_extensions, &pProfileDesc->pRequiredProfiles[required_profile_index], &supported, supported_blocks, unsupported_blocks); - if (result != VK_SUCCESS) { - *pSupported = supported; - return result; - } - } - - const std::vector& blocks = supported ? supported_blocks : unsupported_blocks; - - if (pProperties == nullptr) { - *pPropertyCount = static_cast(blocks.size()); - } else { - if (*pPropertyCount < static_cast(blocks.size())) { - result = VK_INCOMPLETE; - } else { - *pPropertyCount = static_cast(blocks.size()); - } - for (uint32_t block_index = 0, block_count = static_cast(blocks.size()); block_index < block_count; ++block_index) { - pProperties[block_index] = blocks[block_index]; - } - } - - *pSupported = supported; - return result; + const VpCapabilities_T &vp = VpCapabilities_T::Get(); +#endif // VP_USE_OBJECT + + VkResult result = VK_SUCCESS; + + uint32_t api_version = VK_API_VERSION_1_0; + PFN_vkEnumerateInstanceVersion pfnEnumerateInstanceVersion = vp.singleton ? + (PFN_vkEnumerateInstanceVersion) vkGetInstanceProcAddr(VK_NULL_HANDLE, "vkEnumerateInstanceVersion") : + vp.EnumerateInstanceVersion; + if (pfnEnumerateInstanceVersion != nullptr) + { + result = pfnEnumerateInstanceVersion(&api_version); + if (result != VK_SUCCESS) + { + *pSupported = VK_FALSE; + return result; + } /* else { + VP_DEBUG_MSGF("Instance API version %u.%u.%u", VK_API_VERSION_MAJOR(api_version), VK_API_VERSION_MINOR(api_version), VK_API_VERSION_PATCH(api_version)); + } */ + } + + uint32_t supported_instance_extension_count = 0; + result = vp.EnumerateInstanceExtensionProperties(pLayerName, &supported_instance_extension_count, nullptr); + if (result != VK_SUCCESS) + { + *pSupported = VK_FALSE; + return result; + } + std::vector supported_instance_extensions; + if (supported_instance_extension_count > 0) + { + supported_instance_extensions.resize(supported_instance_extension_count); + } + result = vp.EnumerateInstanceExtensionProperties(pLayerName, &supported_instance_extension_count, supported_instance_extensions.data()); + if (result != VK_SUCCESS) + { + *pSupported = VK_FALSE; + return result; + } + + VkBool32 supported = VK_TRUE; + + // We require VK_KHR_get_physical_device_properties2 if we are on Vulkan 1.0 + if (api_version < VK_API_VERSION_1_1) + { + bool foundGPDP2 = false; + for (size_t ext_index = 0, ext_count = supported_instance_extensions.size(); ext_index < ext_count; ++ext_index) + { + if (strcmp(supported_instance_extensions[ext_index].extensionName, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME) == 0) + { + foundGPDP2 = true; + break; + } + } + if (!foundGPDP2) + { + VP_DEBUG_MSG("Unsupported mandatory extension VK_KHR_get_physical_device_properties2 on Vulkan 1.0"); + supported = VK_FALSE; + } + } + + const detail::VpProfileDesc *pProfileDesc = detail::vpGetProfileDesc(pProfile->profileName); + if (pProfileDesc == nullptr) + return VK_ERROR_UNKNOWN; + + std::vector supported_blocks; + std::vector unsupported_blocks; + + result = detail::vpGetInstanceProfileSupportSingleProfile(api_version, supported_instance_extensions, pProfile, &supported, supported_blocks, unsupported_blocks); + if (result != VK_SUCCESS) + { + *pSupported = supported; + return result; + } + + for (std::size_t required_profile_index = 0; required_profile_index < pProfileDesc->requiredProfileCount; ++required_profile_index) + { + result = detail::vpGetInstanceProfileSupportSingleProfile(0, supported_instance_extensions, &pProfileDesc->pRequiredProfiles[required_profile_index], &supported, supported_blocks, unsupported_blocks); + if (result != VK_SUCCESS) + { + *pSupported = supported; + return result; + } + } + + const std::vector &blocks = supported ? supported_blocks : unsupported_blocks; + + if (pProperties == nullptr) + { + *pPropertyCount = static_cast(blocks.size()); + } + else + { + if (*pPropertyCount < static_cast(blocks.size())) + { + result = VK_INCOMPLETE; + } + else + { + *pPropertyCount = static_cast(blocks.size()); + } + for (uint32_t block_index = 0, block_count = static_cast(blocks.size()); block_index < block_count; ++block_index) + { + pProperties[block_index] = blocks[block_index]; + } + } + + *pSupported = supported; + return result; } VPAPI_ATTR VkResult vpGetInstanceProfileSupport( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const char* pLayerName, - const VpProfileProperties* pProfile, - VkBool32* pSupported) { - uint32_t count = 0; - - return vpGetInstanceProfileVariantsSupport( + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const char *pLayerName, + const VpProfileProperties *pProfile, + VkBool32 *pSupported) +{ + uint32_t count = 0; + + return vpGetInstanceProfileVariantsSupport( #ifdef VP_USE_OBJECT - capabilities, -#endif//VP_USE_OBJECT - pLayerName, pProfile, pSupported, &count, nullptr); + capabilities, +#endif // VP_USE_OBJECT + pLayerName, pProfile, pSupported, &count, nullptr); } VPAPI_ATTR VkResult vpCreateInstance( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpInstanceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkInstance* pInstance) { + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpInstanceCreateInfo *pCreateInfo, + const VkAllocationCallbacks *pAllocator, + VkInstance *pInstance) +{ #ifdef VP_USE_OBJECT - const VpCapabilities_T& vp = capabilities == nullptr ? VpCapabilities_T::Get() : *capabilities; + const VpCapabilities_T &vp = capabilities == nullptr ? VpCapabilities_T::Get() : *capabilities; #else - const VpCapabilities_T& vp = VpCapabilities_T::Get(); -#endif//VP_USE_OBJECT - - if (pCreateInfo == nullptr || pInstance == nullptr) { - return vp.CreateInstance(pCreateInfo == nullptr ? nullptr : pCreateInfo->pCreateInfo, pAllocator, pInstance); - } - - const std::vector& blocks = detail::GatherBlocks( - pCreateInfo->enabledFullProfileCount, pCreateInfo->pEnabledFullProfiles, - pCreateInfo->enabledProfileBlockCount, pCreateInfo->pEnabledProfileBlocks); - - std::vector extensions; - for (std::uint32_t ext_index = 0, ext_count = pCreateInfo->pCreateInfo->enabledExtensionCount; ext_index < ext_count; ++ext_index) { - extensions.push_back(pCreateInfo->pCreateInfo->ppEnabledExtensionNames[ext_index]); - } - - for (std::size_t block_index = 0, block_count = blocks.size(); block_index < block_count; ++block_index) { - const detail::VpProfileDesc* profile_desc = detail::vpGetProfileDesc(blocks[block_index].profiles.profileName); - if (profile_desc == nullptr) { - return VK_ERROR_UNKNOWN; - } - - for (std::size_t caps_index = 0, caps_count = profile_desc->requiredCapabilityCount; caps_index < caps_count; ++caps_index) { - const detail::VpCapabilitiesDesc* caps_desc = &profile_desc->pRequiredCapabilities[caps_index]; - - for (std::size_t variant_index = 0, variant_count = caps_desc->variantCount; variant_index < variant_count; ++variant_index) { - const detail::VpVariantDesc* variant = &caps_desc->pVariants[variant_index]; - - if (strcmp(blocks[block_index].blockName, "") != 0) { - if (strcmp(variant->blockName, blocks[block_index].blockName) != 0) { - continue; - } - } - - detail::GetExtensions(variant->instanceExtensionCount, variant->pInstanceExtensions, extensions); - } - } - } - - VkApplicationInfo appInfo{VK_STRUCTURE_TYPE_APPLICATION_INFO}; - if (pCreateInfo->pCreateInfo->pApplicationInfo != nullptr) { - appInfo = *pCreateInfo->pCreateInfo->pApplicationInfo; - } else if (!blocks.empty()) { - appInfo.apiVersion = vpGetProfileAPIVersion( + const VpCapabilities_T &vp = VpCapabilities_T::Get(); +#endif // VP_USE_OBJECT + + if (pCreateInfo == nullptr || pInstance == nullptr) + { + return vp.CreateInstance(pCreateInfo == nullptr ? nullptr : pCreateInfo->pCreateInfo, pAllocator, pInstance); + } + + const std::vector &blocks = detail::GatherBlocks( + pCreateInfo->enabledFullProfileCount, pCreateInfo->pEnabledFullProfiles, + pCreateInfo->enabledProfileBlockCount, pCreateInfo->pEnabledProfileBlocks); + + std::vector extensions; + for (std::uint32_t ext_index = 0, ext_count = pCreateInfo->pCreateInfo->enabledExtensionCount; ext_index < ext_count; ++ext_index) + { + extensions.push_back(pCreateInfo->pCreateInfo->ppEnabledExtensionNames[ext_index]); + } + + for (std::size_t block_index = 0, block_count = blocks.size(); block_index < block_count; ++block_index) + { + const detail::VpProfileDesc *profile_desc = detail::vpGetProfileDesc(blocks[block_index].profiles.profileName); + if (profile_desc == nullptr) + { + return VK_ERROR_UNKNOWN; + } + + for (std::size_t caps_index = 0, caps_count = profile_desc->requiredCapabilityCount; caps_index < caps_count; ++caps_index) + { + const detail::VpCapabilitiesDesc *caps_desc = &profile_desc->pRequiredCapabilities[caps_index]; + + for (std::size_t variant_index = 0, variant_count = caps_desc->variantCount; variant_index < variant_count; ++variant_index) + { + const detail::VpVariantDesc *variant = &caps_desc->pVariants[variant_index]; + + if (strcmp(blocks[block_index].blockName, "") != 0) + { + if (strcmp(variant->blockName, blocks[block_index].blockName) != 0) + { + continue; + } + } + + detail::GetExtensions(variant->instanceExtensionCount, variant->pInstanceExtensions, extensions); + } + } + } + + VkApplicationInfo appInfo{VK_STRUCTURE_TYPE_APPLICATION_INFO}; + if (pCreateInfo->pCreateInfo->pApplicationInfo != nullptr) + { + appInfo = *pCreateInfo->pCreateInfo->pApplicationInfo; + } + else if (!blocks.empty()) + { + appInfo.apiVersion = vpGetProfileAPIVersion( #ifdef VP_USE_OBJECT - capabilities, -#endif//VP_USE_OBJECT - &blocks[0].profiles); - } - - VkInstanceCreateInfo createInfo = *pCreateInfo->pCreateInfo; - createInfo.pApplicationInfo = &appInfo; - - // Need to include VK_KHR_get_physical_device_properties2 if we are on Vulkan 1.0 - if (createInfo.pApplicationInfo->apiVersion < VK_API_VERSION_1_1) { - bool foundGPDP2 = false; - for (size_t ext_index = 0, ext_count = extensions.size(); ext_index < ext_count; ++ext_index) { - if (strcmp(extensions[ext_index], VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME) == 0) { - foundGPDP2 = true; - break; - } - } - if (!foundGPDP2) { - extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); - } - } + capabilities, +#endif // VP_USE_OBJECT + &blocks[0].profiles); + } + + VkInstanceCreateInfo createInfo = *pCreateInfo->pCreateInfo; + createInfo.pApplicationInfo = &appInfo; + + // Need to include VK_KHR_get_physical_device_properties2 if we are on Vulkan 1.0 + if (createInfo.pApplicationInfo->apiVersion < VK_API_VERSION_1_1) + { + bool foundGPDP2 = false; + for (size_t ext_index = 0, ext_count = extensions.size(); ext_index < ext_count; ++ext_index) + { + if (strcmp(extensions[ext_index], VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME) == 0) + { + foundGPDP2 = true; + break; + } + } + if (!foundGPDP2) + { + extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + } + } #ifdef __APPLE__ - bool has_portability_ext = false; - for (std::size_t ext_index = 0, ext_count = extensions.size(); ext_index < ext_count; ++ext_index) { - if (strcmp(extensions[ext_index], VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME) == 0) { - has_portability_ext = true; - break; - } - } - - if (!has_portability_ext) { - extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME); - } - - createInfo.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR; + bool has_portability_ext = false; + for (std::size_t ext_index = 0, ext_count = extensions.size(); ext_index < ext_count; ++ext_index) + { + if (strcmp(extensions[ext_index], VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME) == 0) + { + has_portability_ext = true; + break; + } + } + + if (!has_portability_ext) + { + extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME); + } + + createInfo.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR; #endif - if (!extensions.empty()) { - createInfo.enabledExtensionCount = static_cast(extensions.size()); - createInfo.ppEnabledExtensionNames = extensions.data(); - } + if (!extensions.empty()) + { + createInfo.enabledExtensionCount = static_cast(extensions.size()); + createInfo.ppEnabledExtensionNames = extensions.data(); + } - return vp.CreateInstance(&createInfo, pAllocator, pInstance); + return vp.CreateInstance(&createInfo, pAllocator, pInstance); } VPAPI_ATTR VkResult vpGetPhysicalDeviceProfileVariantsSupport( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - VkInstance instance, - VkPhysicalDevice physicalDevice, + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + VkInstance instance, + VkPhysicalDevice physicalDevice, const VpProfileProperties *pProfile, - VkBool32 *pSupported, - uint32_t *pPropertyCount, - VpBlockProperties* pProperties) { + VkBool32 *pSupported, + uint32_t *pPropertyCount, + VpBlockProperties *pProperties) +{ #ifdef VP_USE_OBJECT - const VpCapabilities_T& vp = capabilities == nullptr ? VpCapabilities_T::Get() : *capabilities; + const VpCapabilities_T &vp = capabilities == nullptr ? VpCapabilities_T::Get() : *capabilities; #else - const VpCapabilities_T& vp = VpCapabilities_T::Get(); -#endif//VP_USE_OBJECT - - VkResult result = VK_SUCCESS; - - uint32_t supported_device_extension_count = 0; - result = vp.EnumerateDeviceExtensionProperties(physicalDevice, nullptr, &supported_device_extension_count, nullptr); - if (result != VK_SUCCESS) { - return result; - } - std::vector supported_device_extensions; - if (supported_device_extension_count > 0) { - supported_device_extensions.resize(supported_device_extension_count); - } - result = vp.EnumerateDeviceExtensionProperties(physicalDevice, nullptr, &supported_device_extension_count, supported_device_extensions.data()); - if (result != VK_SUCCESS) { - return result; - } - - // Workaround old loader bug where count could be smaller on the second call to vkEnumerateDeviceExtensionProperties - if (supported_device_extension_count > 0) { - supported_device_extensions.resize(supported_device_extension_count); - } - - { - const detail::VpProfileDesc* pProfileDesc = detail::vpGetProfileDesc(pProfile->profileName); - if (pProfileDesc == nullptr) { - return VK_ERROR_UNKNOWN; - } - } - - struct GPDP2EntryPoints { - PFN_vkGetPhysicalDeviceFeatures2KHR pfnGetPhysicalDeviceFeatures2; - PFN_vkGetPhysicalDeviceProperties2KHR pfnGetPhysicalDeviceProperties2; - PFN_vkGetPhysicalDeviceFormatProperties2KHR pfnGetPhysicalDeviceFormatProperties2; - PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR pfnGetPhysicalDeviceQueueFamilyProperties2; - }; - - std::vector supported_blocks; - std::vector unsupported_blocks; - - struct UserData { - VkPhysicalDevice physicalDevice; - std::vector& supported_blocks; - std::vector& unsupported_blocks; - const detail::VpVariantDesc* variant; - GPDP2EntryPoints gpdp2; - uint32_t index; - uint32_t count; - detail::PFN_vpStructChainerCb pfnCb; - bool supported; - } userData{physicalDevice, supported_blocks, unsupported_blocks}; - - if (!vp.singleton) { - userData.gpdp2.pfnGetPhysicalDeviceFeatures2 = vp.GetPhysicalDeviceFeatures2; - userData.gpdp2.pfnGetPhysicalDeviceProperties2 = vp.GetPhysicalDeviceProperties2; - userData.gpdp2.pfnGetPhysicalDeviceFormatProperties2 = vp.GetPhysicalDeviceFormatProperties2; - userData.gpdp2.pfnGetPhysicalDeviceQueueFamilyProperties2 = vp.GetPhysicalDeviceQueueFamilyProperties2; - } - - // Attempt to load core versions of the GPDP2 entry points - if (userData.gpdp2.pfnGetPhysicalDeviceFeatures2 == nullptr) { - userData.gpdp2.pfnGetPhysicalDeviceFeatures2 = - (PFN_vkGetPhysicalDeviceFeatures2KHR)vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2"); - userData.gpdp2.pfnGetPhysicalDeviceProperties2 = - (PFN_vkGetPhysicalDeviceProperties2KHR)vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2"); - userData.gpdp2.pfnGetPhysicalDeviceFormatProperties2 = - (PFN_vkGetPhysicalDeviceFormatProperties2KHR)vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFormatProperties2"); - userData.gpdp2.pfnGetPhysicalDeviceQueueFamilyProperties2 = - (PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties2"); - } - - // If not successful, try to load KHR variant - if (userData.gpdp2.pfnGetPhysicalDeviceFeatures2 == nullptr) { - userData.gpdp2.pfnGetPhysicalDeviceFeatures2 = - (PFN_vkGetPhysicalDeviceFeatures2KHR)vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2KHR"); - userData.gpdp2.pfnGetPhysicalDeviceProperties2 = - (PFN_vkGetPhysicalDeviceProperties2KHR)vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2KHR"); - userData.gpdp2.pfnGetPhysicalDeviceFormatProperties2 = - (PFN_vkGetPhysicalDeviceFormatProperties2KHR)vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFormatProperties2KHR"); - userData.gpdp2.pfnGetPhysicalDeviceQueueFamilyProperties2 = - (PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR"); - } - - if (userData.gpdp2.pfnGetPhysicalDeviceFeatures2 == nullptr || - userData.gpdp2.pfnGetPhysicalDeviceProperties2 == nullptr || - userData.gpdp2.pfnGetPhysicalDeviceFormatProperties2 == nullptr || - userData.gpdp2.pfnGetPhysicalDeviceQueueFamilyProperties2 == nullptr) { - return VK_ERROR_EXTENSION_NOT_PRESENT; - } - - bool supported = true; - - const std::vector& gathered_profiles = detail::GatherProfiles(*pProfile); - - for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) { - const char* profile_name = gathered_profiles[profile_index].profileName; - - const detail::VpProfileDesc* profile_desc = detail::vpGetProfileDesc(profile_name); - if (profile_desc == nullptr) { - return VK_ERROR_UNKNOWN; - } - - bool supported_profile = true; - - if (profile_desc->props.specVersion < gathered_profiles[profile_index].specVersion) { - supported_profile = false; - } - - VpBlockProperties block{gathered_profiles[profile_index], profile_desc->minApiVersion}; - - { - VkPhysicalDeviceProperties2KHR properties2{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR }; - userData.gpdp2.pfnGetPhysicalDeviceProperties2(physicalDevice, &properties2); - if (!detail::vpCheckVersion(properties2.properties.apiVersion, profile_desc->minApiVersion)) { - supported_profile = false; - } - } - - for (uint32_t required_capability_index = 0; required_capability_index < profile_desc->requiredCapabilityCount; ++required_capability_index) { - const detail::VpCapabilitiesDesc* required_capabilities = &profile_desc->pRequiredCapabilities[required_capability_index]; - - bool supported_block = false; - - for (uint32_t variant_index = 0; variant_index < required_capabilities->variantCount; ++variant_index) { - const detail::VpVariantDesc& variant_desc = required_capabilities->pVariants[variant_index]; - - bool supported_variant = true; - - for (uint32_t ext_index = 0; ext_index < variant_desc.deviceExtensionCount; ++ext_index) { - const char *requested_extension = variant_desc.pDeviceExtensions[ext_index].extensionName; - if (!detail::CheckExtension(supported_device_extensions.data(), supported_device_extensions.size(), requested_extension)) { - supported_variant = false; - } - } - - userData.variant = &variant_desc; - - VkPhysicalDeviceFeatures2KHR features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR }; - userData.variant->chainers.pfnFeature( - static_cast(static_cast(&features)), &userData, - [](VkBaseOutStructure* p, void* pUser) { - UserData* pUserData = static_cast(pUser); - pUserData->gpdp2.pfnGetPhysicalDeviceFeatures2( - pUserData->physicalDevice, - static_cast(static_cast(p))); - - pUserData->supported = true; - while (p != nullptr) { - if (!pUserData->variant->feature.pfnComparator(p)) { - pUserData->supported = false; - } - p = p->pNext; - } - } - ); - if (!userData.supported) { - supported_variant = false; - } - - VkPhysicalDeviceProperties2KHR device_properties2{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR }; - userData.variant->chainers.pfnProperty( - static_cast(static_cast(&device_properties2)), &userData, - [](VkBaseOutStructure* p, void* pUser) { - UserData* pUserData = static_cast(pUser); - pUserData->gpdp2.pfnGetPhysicalDeviceProperties2( - pUserData->physicalDevice, - static_cast(static_cast(p))); - - pUserData->supported = true; - while (p != nullptr) { - if (!pUserData->variant->property.pfnComparator(p)) { - pUserData->supported = false; - } - p = p->pNext; - } - } - ); - if (!userData.supported) { - supported_variant = false; - } - - for (uint32_t format_index = 0; format_index < userData.variant->formatCount && supported_variant; ++format_index) { - userData.index = format_index; - VkFormatProperties2KHR format_properties2{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR }; - userData.variant->chainers.pfnFormat( - static_cast(static_cast(&format_properties2)), &userData, - [](VkBaseOutStructure* p, void* pUser) { - UserData* pUserData = static_cast(pUser); - pUserData->gpdp2.pfnGetPhysicalDeviceFormatProperties2( - pUserData->physicalDevice, - pUserData->variant->pFormats[pUserData->index].format, - static_cast(static_cast(p))); - pUserData->supported = true; - while (p != nullptr) { - if (!pUserData->variant->pFormats[pUserData->index].pfnComparator(p)) { - pUserData->supported = false; - } - p = p->pNext; - } - } - ); - if (!userData.supported) { - supported_variant = false; - } - } - - memcpy(block.blockName, variant_desc.blockName, VP_MAX_PROFILE_NAME_SIZE * sizeof(char)); - if (supported_variant) { - supported_blocks.push_back(block); - supported_block = true; - break; - } else { - unsupported_blocks.push_back(block); - } - } - - if (!supported_block) { - supported_profile = false; - } - } - - if (!supported_profile) { - supported = false; - } - } - - const std::vector& blocks = supported ? supported_blocks : unsupported_blocks; - - if (pProperties == nullptr) { - *pPropertyCount = static_cast(blocks.size()); - } else { - if (*pPropertyCount < static_cast(blocks.size())) { - result = VK_INCOMPLETE; - } else { - *pPropertyCount = static_cast(blocks.size()); - } - for (uint32_t i = 0, n = static_cast(blocks.size()); i < n; ++i) { - pProperties[i] = blocks[i]; - } - } - - *pSupported = supported ? VK_TRUE : VK_FALSE; - return VK_SUCCESS; + const VpCapabilities_T &vp = VpCapabilities_T::Get(); +#endif // VP_USE_OBJECT + + VkResult result = VK_SUCCESS; + + uint32_t supported_device_extension_count = 0; + result = vp.EnumerateDeviceExtensionProperties(physicalDevice, nullptr, &supported_device_extension_count, nullptr); + if (result != VK_SUCCESS) + { + return result; + } + std::vector supported_device_extensions; + if (supported_device_extension_count > 0) + { + supported_device_extensions.resize(supported_device_extension_count); + } + result = vp.EnumerateDeviceExtensionProperties(physicalDevice, nullptr, &supported_device_extension_count, supported_device_extensions.data()); + if (result != VK_SUCCESS) + { + return result; + } + + // Workaround old loader bug where count could be smaller on the second call to vkEnumerateDeviceExtensionProperties + if (supported_device_extension_count > 0) + { + supported_device_extensions.resize(supported_device_extension_count); + } + + { + const detail::VpProfileDesc *pProfileDesc = detail::vpGetProfileDesc(pProfile->profileName); + if (pProfileDesc == nullptr) + { + return VK_ERROR_UNKNOWN; + } + } + + struct GPDP2EntryPoints + { + PFN_vkGetPhysicalDeviceFeatures2KHR pfnGetPhysicalDeviceFeatures2; + PFN_vkGetPhysicalDeviceProperties2KHR pfnGetPhysicalDeviceProperties2; + PFN_vkGetPhysicalDeviceFormatProperties2KHR pfnGetPhysicalDeviceFormatProperties2; + PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR pfnGetPhysicalDeviceQueueFamilyProperties2; + }; + +#ifdef VK_KHR_video_queue + struct VideoInfo + { + PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR pfnGetPhysicalDeviceVideoCapabilitiesKHR; + PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR pfnGetPhysicalDeviceVideoFormatPropertiesKHR; + const detail::VpVideoProfileDesc *pProfileDesc; + VkVideoProfileInfoKHR profileInfo; + VkPhysicalDeviceVideoFormatInfoKHR formatInfo; + bool supportedProfile; + uint32_t matchingProfiles; + }; +#endif // VK_KHR_video_queue + + std::vector supported_blocks; + std::vector unsupported_blocks; + + struct UserData + { + VkPhysicalDevice physicalDevice; + std::vector &supported_blocks; + std::vector &unsupported_blocks; + const detail::VpVariantDesc *variant; + GPDP2EntryPoints gpdp2; +#ifdef VK_KHR_video_queue + VideoInfo video; +#endif // VK_KHR_video_queue + uint32_t index; + detail::PFN_vpStructChainerCb pfnCb; + bool supported; + } userData{physicalDevice, supported_blocks, unsupported_blocks}; + + if (!vp.singleton) + { + userData.gpdp2.pfnGetPhysicalDeviceFeatures2 = vp.GetPhysicalDeviceFeatures2; + userData.gpdp2.pfnGetPhysicalDeviceProperties2 = vp.GetPhysicalDeviceProperties2; + userData.gpdp2.pfnGetPhysicalDeviceFormatProperties2 = vp.GetPhysicalDeviceFormatProperties2; + userData.gpdp2.pfnGetPhysicalDeviceQueueFamilyProperties2 = vp.GetPhysicalDeviceQueueFamilyProperties2; + } + + // Attempt to load core versions of the GPDP2 entry points + if (userData.gpdp2.pfnGetPhysicalDeviceFeatures2 == nullptr) + { + userData.gpdp2.pfnGetPhysicalDeviceFeatures2 = + (PFN_vkGetPhysicalDeviceFeatures2KHR) vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2"); + userData.gpdp2.pfnGetPhysicalDeviceProperties2 = + (PFN_vkGetPhysicalDeviceProperties2KHR) vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2"); + userData.gpdp2.pfnGetPhysicalDeviceFormatProperties2 = + (PFN_vkGetPhysicalDeviceFormatProperties2KHR) vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFormatProperties2"); + userData.gpdp2.pfnGetPhysicalDeviceQueueFamilyProperties2 = + (PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR) vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties2"); + } + + // If not successful, try to load KHR variant + if (userData.gpdp2.pfnGetPhysicalDeviceFeatures2 == nullptr) + { + userData.gpdp2.pfnGetPhysicalDeviceFeatures2 = + (PFN_vkGetPhysicalDeviceFeatures2KHR) vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2KHR"); + userData.gpdp2.pfnGetPhysicalDeviceProperties2 = + (PFN_vkGetPhysicalDeviceProperties2KHR) vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2KHR"); + userData.gpdp2.pfnGetPhysicalDeviceFormatProperties2 = + (PFN_vkGetPhysicalDeviceFormatProperties2KHR) vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFormatProperties2KHR"); + userData.gpdp2.pfnGetPhysicalDeviceQueueFamilyProperties2 = + (PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR) vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR"); + } + + if (userData.gpdp2.pfnGetPhysicalDeviceFeatures2 == nullptr || + userData.gpdp2.pfnGetPhysicalDeviceProperties2 == nullptr || + userData.gpdp2.pfnGetPhysicalDeviceFormatProperties2 == nullptr || + userData.gpdp2.pfnGetPhysicalDeviceQueueFamilyProperties2 == nullptr) + { + return VK_ERROR_EXTENSION_NOT_PRESENT; + } + +#ifdef VK_KHR_video_queue + PFN_vkGetInstanceProcAddr gipa = vp.singleton ? vkGetInstanceProcAddr : vp.GetInstanceProcAddr; + userData.video.pfnGetPhysicalDeviceVideoCapabilitiesKHR = + (PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR) gipa(instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR"); + userData.video.pfnGetPhysicalDeviceVideoFormatPropertiesKHR = + (PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR) gipa(instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR"); +#endif // VK_KHR_video_queue + + bool supported = true; + + const std::vector &gathered_profiles = detail::GatherProfiles(*pProfile); + + for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) + { + const char *profile_name = gathered_profiles[profile_index].profileName; + + const detail::VpProfileDesc *profile_desc = detail::vpGetProfileDesc(profile_name); + if (profile_desc == nullptr) + { + return VK_ERROR_UNKNOWN; + } + + bool supported_profile = true; + + if (profile_desc->props.specVersion < gathered_profiles[profile_index].specVersion) + { + VP_DEBUG_MSGF("Unsupported requested %s profile version: %u, profile supported at version %u", profile_name, profile_desc->props.specVersion, pProfile->specVersion); + supported_profile = false; + } + + VpBlockProperties block{gathered_profiles[profile_index], profile_desc->minApiVersion}; + + { + VkPhysicalDeviceProperties2KHR properties2{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR}; + userData.gpdp2.pfnGetPhysicalDeviceProperties2(physicalDevice, &properties2); + if (!detail::vpCheckVersion(properties2.properties.apiVersion, profile_desc->minApiVersion)) + { + VP_DEBUG_MSGF("Unsupported API version: %u.%u.%u", VK_API_VERSION_MAJOR(profile_desc->minApiVersion), VK_API_VERSION_MINOR(profile_desc->minApiVersion), VK_API_VERSION_PATCH(profile_desc->minApiVersion)); + supported_profile = false; + } + } + + for (uint32_t required_capability_index = 0; required_capability_index < profile_desc->requiredCapabilityCount; ++required_capability_index) + { + const detail::VpCapabilitiesDesc *required_capabilities = &profile_desc->pRequiredCapabilities[required_capability_index]; + + bool supported_block = false; + + for (uint32_t variant_index = 0; variant_index < required_capabilities->variantCount; ++variant_index) + { + const detail::VpVariantDesc &variant_desc = required_capabilities->pVariants[variant_index]; + + bool supported_variant = true; + + for (uint32_t ext_index = 0; ext_index < variant_desc.deviceExtensionCount; ++ext_index) + { + const char *requested_extension = variant_desc.pDeviceExtensions[ext_index].extensionName; + if (!detail::CheckExtension(supported_device_extensions.data(), supported_device_extensions.size(), requested_extension)) + { + supported_variant = false; + } + } + + userData.variant = &variant_desc; + + VkPhysicalDeviceFeatures2KHR features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR}; + userData.variant->chainers.pfnFeature( + static_cast(static_cast(&features)), &userData, + [](VkBaseOutStructure *p, void *pUser) { + UserData *pUserData = static_cast(pUser); + pUserData->gpdp2.pfnGetPhysicalDeviceFeatures2( + pUserData->physicalDevice, + static_cast(static_cast(p))); + + pUserData->supported = true; + while (p != nullptr) + { + if (!pUserData->variant->feature.pfnComparator(p)) + { + pUserData->supported = false; + } + p = p->pNext; + } + }); + if (!userData.supported) + { + supported_variant = false; + } + + VkPhysicalDeviceProperties2KHR device_properties2{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR}; + userData.variant->chainers.pfnProperty( + static_cast(static_cast(&device_properties2)), &userData, + [](VkBaseOutStructure *p, void *pUser) { + UserData *pUserData = static_cast(pUser); + pUserData->gpdp2.pfnGetPhysicalDeviceProperties2( + pUserData->physicalDevice, + static_cast(static_cast(p))); + + pUserData->supported = true; + while (p != nullptr) + { + if (!pUserData->variant->property.pfnComparator(p)) + { + pUserData->supported = false; + } + p = p->pNext; + } + }); + if (!userData.supported) + { + supported_variant = false; + } + + if (userData.variant->queueFamilyCount > 0) + { + uint32_t queue_family_count = 0; + userData.gpdp2.pfnGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, &queue_family_count, nullptr); + std::vector queueFamilyProps(queue_family_count, {VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR}); + userData.variant->chainers.pfnQueueFamily( + queue_family_count, static_cast(static_cast(queueFamilyProps.data())), &userData, + [](uint32_t queue_family_count, VkBaseOutStructure *pBaseArray, void *pUser) { + UserData *pUserData = static_cast(pUser); + VkQueueFamilyProperties2KHR *pArray = static_cast(static_cast(pBaseArray)); + pUserData->gpdp2.pfnGetPhysicalDeviceQueueFamilyProperties2(pUserData->physicalDevice, &queue_family_count, pArray); + pUserData->supported = true; + for (uint32_t profile_qf_idx = 0; profile_qf_idx < pUserData->variant->queueFamilyCount; ++profile_qf_idx) + { + bool found_matching = false; + for (uint32_t queue_family_index = 0; queue_family_index < queue_family_count; ++queue_family_index) + { + bool this_matches = true; + VkBaseOutStructure *p = static_cast(static_cast(&pArray[queue_family_index])); + while (p != nullptr) + { + if (!pUserData->variant->pQueueFamilies[profile_qf_idx].pfnComparator(p)) + { + this_matches = false; + } + p = p->pNext; + } + if (this_matches) + { + found_matching = true; + break; + } + } + if (!found_matching) + { + pUserData->supported = false; + break; + } + } + }); + if (!userData.supported) + { + supported_variant = false; + } + } + + for (uint32_t format_index = 0; format_index < userData.variant->formatCount && supported_variant; ++format_index) + { + userData.index = format_index; + VkFormatProperties2KHR format_properties2{VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR}; + userData.variant->chainers.pfnFormat( + static_cast(static_cast(&format_properties2)), &userData, + [](VkBaseOutStructure *p, void *pUser) { + UserData *pUserData = static_cast(pUser); + pUserData->gpdp2.pfnGetPhysicalDeviceFormatProperties2( + pUserData->physicalDevice, + pUserData->variant->pFormats[pUserData->index].format, + static_cast(static_cast(p))); + pUserData->supported = true; + while (p != nullptr) + { + if (!pUserData->variant->pFormats[pUserData->index].pfnComparator(p)) + { + pUserData->supported = false; + } + p = p->pNext; + } + }); + if (!userData.supported) + { + supported_variant = false; + } + } + +#ifdef VK_KHR_video_queue + if (userData.variant->videoProfileCount > 0) + { + VkVideoProfileListInfoKHR profile_list{VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR}; + profile_list.profileCount = 1; + profile_list.pProfiles = &userData.video.profileInfo; + userData.video.formatInfo.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR; + userData.video.formatInfo.pNext = &profile_list; + + if (userData.video.pfnGetPhysicalDeviceVideoCapabilitiesKHR != nullptr && + userData.video.pfnGetPhysicalDeviceVideoFormatPropertiesKHR != nullptr) + { + for (uint32_t video_profile_index = 0; video_profile_index < userData.variant->videoProfileCount; ++video_profile_index) + { + userData.video.profileInfo = VkVideoProfileInfoKHR{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR}; + userData.video.pProfileDesc = &userData.variant->pVideoProfiles[video_profile_index]; + userData.supported = true; + userData.video.matchingProfiles = 0; + + detail::vpForEachMatchingVideoProfiles(&userData.video.profileInfo, &userData, + [](VkBaseOutStructure *p, void *pUser) { + UserData *pUserData = static_cast(pUser); + while (p != nullptr) + { + if (!pUserData->video.pProfileDesc->info.pfnComparator(p)) + { + return; + } + p = p->pNext; + } + + pUserData->video.supportedProfile = true; + + VkVideoCapabilitiesKHR capabilities{VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR}; + pUserData->video.pProfileDesc->chainers.pfnCapability( + static_cast(static_cast(&capabilities)), pUserData, + [](VkBaseOutStructure *p, void *pUser) { + UserData *pUserData = static_cast(pUser); + VkResult result = pUserData->video.pfnGetPhysicalDeviceVideoCapabilitiesKHR( + pUserData->physicalDevice, + &pUserData->video.profileInfo, + static_cast(static_cast(p))); + if (result != VK_SUCCESS) + { + pUserData->video.supportedProfile = false; + return; + } + while (p != nullptr) + { + if (!pUserData->video.pProfileDesc->capability.pfnComparator(p)) + { + pUserData->supported = false; + } + p = p->pNext; + } + }); + + if (pUserData->video.supportedProfile) + { + pUserData->video.matchingProfiles++; + } + else + { + return; + } + + std::vector format_props; + for (uint32_t format_index = 0; format_index < pUserData->video.pProfileDesc->formatCount; ++format_index) + { + pUserData->index = format_index; + { + VkVideoFormatPropertiesKHR tmp_props{VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR}; + pUserData->video.pProfileDesc->pFormats[format_index].pfnFiller(static_cast(static_cast(&tmp_props))); + pUserData->video.formatInfo.imageUsage = tmp_props.imageUsageFlags; + } + + uint32_t format_count = 0; + pUserData->video.pfnGetPhysicalDeviceVideoFormatPropertiesKHR(pUserData->physicalDevice, &pUserData->video.formatInfo, &format_count, nullptr); + format_props.resize(format_count, {VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR}); + pUserData->video.pProfileDesc->chainers.pfnFormat( + format_count, static_cast(static_cast(format_props.data())), pUserData, + [](uint32_t format_count, VkBaseOutStructure *pBaseArray, void *pUser) { + UserData *pUserData = static_cast(pUser); + VkVideoFormatPropertiesKHR *pArray = static_cast(static_cast(pBaseArray)); + pUserData->video.pfnGetPhysicalDeviceVideoFormatPropertiesKHR(pUserData->physicalDevice, &pUserData->video.formatInfo, &format_count, pArray); + bool found_matching = false; + for (uint32_t i = 0; i < format_count; ++i) + { + bool this_matches = true; + VkBaseOutStructure *p = static_cast(static_cast(&pArray[i])); + while (p != nullptr) + { + if (!pUserData->video.pProfileDesc->pFormats[pUserData->index].pfnComparator(p)) + { + this_matches = false; + } + p = p->pNext; + } + if (this_matches) + { + found_matching = true; + break; + } + } + if (!found_matching) + { + pUserData->supported = false; + } + }); + } + }); + if (!userData.supported || userData.video.matchingProfiles == 0) + { + supported_variant = false; + } + } + } + else + { + supported_variant = false; + } + } +#endif // VK_KHR_video_queue + + memcpy(block.blockName, variant_desc.blockName, VP_MAX_PROFILE_NAME_SIZE * sizeof(char)); + if (supported_variant) + { + supported_blocks.push_back(block); + supported_block = true; + break; + } + else + { + unsupported_blocks.push_back(block); + } + } + + if (!supported_block) + { + supported_profile = false; + } + } + + if (!supported_profile) + { + supported = false; + } + } + + const std::vector &blocks = supported ? supported_blocks : unsupported_blocks; + + if (pProperties == nullptr) + { + *pPropertyCount = static_cast(blocks.size()); + } + else + { + if (*pPropertyCount < static_cast(blocks.size())) + { + result = VK_INCOMPLETE; + } + else + { + *pPropertyCount = static_cast(blocks.size()); + } + for (uint32_t i = 0, n = static_cast(blocks.size()); i < n; ++i) + { + pProperties[i] = blocks[i]; + } + } + + *pSupported = supported ? VK_TRUE : VK_FALSE; + return VK_SUCCESS; } VPAPI_ATTR VkResult vpGetPhysicalDeviceProfileSupport( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - VkInstance instance, - VkPhysicalDevice physicalDevice, - const VpProfileProperties* pProfile, - VkBool32 *pSupported) { - uint32_t count = 0; - - return vpGetPhysicalDeviceProfileVariantsSupport( + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + VkInstance instance, + VkPhysicalDevice physicalDevice, + const VpProfileProperties *pProfile, + VkBool32 *pSupported) +{ + uint32_t count = 0; + + return vpGetPhysicalDeviceProfileVariantsSupport( #ifdef VP_USE_OBJECT - capabilities, -#endif//VP_USE_OBJECT - instance, physicalDevice, pProfile, pSupported, &count, nullptr); + capabilities, +#endif // VP_USE_OBJECT + instance, physicalDevice, pProfile, pSupported, &count, nullptr); } VPAPI_ATTR VkResult vpCreateDevice( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - VkPhysicalDevice physicalDevice, - const VpDeviceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDevice* pDevice) { + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + VkPhysicalDevice physicalDevice, + const VpDeviceCreateInfo *pCreateInfo, + const VkAllocationCallbacks *pAllocator, + VkDevice *pDevice) +{ #ifdef VP_USE_OBJECT - const VpCapabilities_T& vp = capabilities == nullptr ? VpCapabilities_T::Get() : *capabilities; + const VpCapabilities_T &vp = capabilities == nullptr ? VpCapabilities_T::Get() : *capabilities; #else - const VpCapabilities_T& vp = VpCapabilities_T::Get(); -#endif//VP_USE_OBJECT - - if (physicalDevice == VK_NULL_HANDLE || pCreateInfo == nullptr || pDevice == nullptr) { - return vp.CreateDevice(physicalDevice, pCreateInfo == nullptr ? nullptr : pCreateInfo->pCreateInfo, pAllocator, pDevice); - } - - const std::vector& blocks = detail::GatherBlocks( - pCreateInfo->enabledFullProfileCount, pCreateInfo->pEnabledFullProfiles, - pCreateInfo->enabledProfileBlockCount, pCreateInfo->pEnabledProfileBlocks); - - std::unique_ptr chain = std::make_unique(); - std::vector structureTypes; - - std::vector extensions; - for (std::uint32_t ext_index = 0, ext_count = pCreateInfo->pCreateInfo->enabledExtensionCount; ext_index < ext_count; ++ext_index) { - extensions.push_back(pCreateInfo->pCreateInfo->ppEnabledExtensionNames[ext_index]); - } - - for (std::size_t block_index = 0, block_count = blocks.size(); block_index < block_count; ++block_index) { - const detail::VpProfileDesc* pProfileDesc = detail::vpGetProfileDesc(blocks[block_index].profiles.profileName); - if (pProfileDesc == nullptr) return VK_ERROR_UNKNOWN; - - for (std::size_t caps_index = 0, caps_count = pProfileDesc->requiredCapabilityCount; caps_index < caps_count; ++caps_index) { - const detail::VpCapabilitiesDesc* pCapsDesc = &pProfileDesc->pRequiredCapabilities[caps_index]; - - for (std::size_t variant_index = 0, variant_count = pCapsDesc->variantCount; variant_index < variant_count; ++variant_index) { - const detail::VpVariantDesc* variant = &pCapsDesc->pVariants[variant_index]; - - if (strcmp(blocks[block_index].blockName, "") != 0) { - if (strcmp(variant->blockName, blocks[block_index].blockName) != 0) { - continue; - } - } - - for (uint32_t type_index = 0; type_index < variant->featureStructTypeCount; ++type_index) { - const VkStructureType type = variant->pFeatureStructTypes[type_index]; - if (std::find(structureTypes.begin(), structureTypes.end(), type) == std::end(structureTypes)) { - structureTypes.push_back(type); - } - } - - detail::GetExtensions(variant->deviceExtensionCount, variant->pDeviceExtensions, extensions); - } - } - } - - VkBaseOutStructure* pNext = static_cast(const_cast(pCreateInfo->pCreateInfo->pNext)); - detail::GatherStructureTypes(structureTypes, pNext); - - chain->Build(structureTypes); - - VkPhysicalDeviceFeatures2KHR* pFeatures = &chain->requiredFeaturesChain; - if (pCreateInfo->pCreateInfo->pEnabledFeatures) { - pFeatures->features = *pCreateInfo->pCreateInfo->pEnabledFeatures; - } - - for (std::size_t block_index = 0, block_count = blocks.size(); block_index < block_count; ++block_index) { - const detail::VpProfileDesc* pProfileDesc = detail::vpGetProfileDesc(blocks[block_index].profiles.profileName); - if (pProfileDesc == nullptr) { - return VK_ERROR_UNKNOWN; - } - - for (std::size_t caps_index = 0, caps_count = pProfileDesc->requiredCapabilityCount; caps_index < caps_count; ++caps_index) { - const detail::VpCapabilitiesDesc* pCapsDesc = &pProfileDesc->pRequiredCapabilities[caps_index]; - - for (std::size_t variant_index = 0, variant_count = pCapsDesc->variantCount; variant_index < variant_count; ++variant_index) { - const detail::VpVariantDesc* variant = &pCapsDesc->pVariants[variant_index]; - - VkBaseOutStructure* base_ptr = reinterpret_cast(pFeatures); - if (variant->feature.pfnFiller != nullptr) { - while (base_ptr != nullptr) { - variant->feature.pfnFiller(base_ptr); - base_ptr = base_ptr->pNext; - } - } - } - } - } - - chain->ApplyFeatures(pCreateInfo); - - if (pCreateInfo->flags & VP_DEVICE_CREATE_DISABLE_ROBUST_BUFFER_ACCESS_BIT) { - pFeatures->features.robustBufferAccess = VK_FALSE; - } - - VkDeviceCreateInfo createInfo{VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO}; - createInfo.pNext = &chain->requiredFeaturesChain; - createInfo.queueCreateInfoCount = pCreateInfo->pCreateInfo->queueCreateInfoCount; - createInfo.pQueueCreateInfos = pCreateInfo->pCreateInfo->pQueueCreateInfos; - createInfo.enabledExtensionCount = static_cast(extensions.size()); - createInfo.ppEnabledExtensionNames = extensions.data(); - - return vp.CreateDevice(physicalDevice, &createInfo, pAllocator, pDevice); + const VpCapabilities_T &vp = VpCapabilities_T::Get(); +#endif // VP_USE_OBJECT + + if (physicalDevice == VK_NULL_HANDLE || pCreateInfo == nullptr || pDevice == nullptr) + { + return vp.CreateDevice(physicalDevice, pCreateInfo == nullptr ? nullptr : pCreateInfo->pCreateInfo, pAllocator, pDevice); + } + + const std::vector &blocks = detail::GatherBlocks( + pCreateInfo->enabledFullProfileCount, pCreateInfo->pEnabledFullProfiles, + pCreateInfo->enabledProfileBlockCount, pCreateInfo->pEnabledProfileBlocks); + + std::unique_ptr chain = std::make_unique(); + std::vector structureTypes; + + std::vector extensions; + for (std::uint32_t ext_index = 0, ext_count = pCreateInfo->pCreateInfo->enabledExtensionCount; ext_index < ext_count; ++ext_index) + { + extensions.push_back(pCreateInfo->pCreateInfo->ppEnabledExtensionNames[ext_index]); + } + + for (std::size_t block_index = 0, block_count = blocks.size(); block_index < block_count; ++block_index) + { + const detail::VpProfileDesc *pProfileDesc = detail::vpGetProfileDesc(blocks[block_index].profiles.profileName); + if (pProfileDesc == nullptr) + return VK_ERROR_UNKNOWN; + + for (std::size_t caps_index = 0, caps_count = pProfileDesc->requiredCapabilityCount; caps_index < caps_count; ++caps_index) + { + const detail::VpCapabilitiesDesc *pCapsDesc = &pProfileDesc->pRequiredCapabilities[caps_index]; + + for (std::size_t variant_index = 0, variant_count = pCapsDesc->variantCount; variant_index < variant_count; ++variant_index) + { + const detail::VpVariantDesc *variant = &pCapsDesc->pVariants[variant_index]; + + if (strcmp(blocks[block_index].blockName, "") != 0) + { + if (strcmp(variant->blockName, blocks[block_index].blockName) != 0) + { + continue; + } + } + + for (uint32_t type_index = 0; type_index < variant->featureStructTypeCount; ++type_index) + { + const VkStructureType type = variant->pFeatureStructTypes[type_index]; + if (std::find(structureTypes.begin(), structureTypes.end(), type) == std::end(structureTypes)) + { + structureTypes.push_back(type); + } + } + + detail::GetExtensions(variant->deviceExtensionCount, variant->pDeviceExtensions, extensions); + } + } + } + + VkBaseOutStructure *pNext = static_cast(const_cast(pCreateInfo->pCreateInfo->pNext)); + detail::GatherStructureTypes(structureTypes, pNext); + + chain->Build(structureTypes); + + VkPhysicalDeviceFeatures2KHR *pFeatures = &chain->requiredFeaturesChain; + if (pCreateInfo->pCreateInfo->pEnabledFeatures) + { + pFeatures->features = *pCreateInfo->pCreateInfo->pEnabledFeatures; + } + + for (std::size_t block_index = 0, block_count = blocks.size(); block_index < block_count; ++block_index) + { + const detail::VpProfileDesc *pProfileDesc = detail::vpGetProfileDesc(blocks[block_index].profiles.profileName); + if (pProfileDesc == nullptr) + { + return VK_ERROR_UNKNOWN; + } + + for (std::size_t caps_index = 0, caps_count = pProfileDesc->requiredCapabilityCount; caps_index < caps_count; ++caps_index) + { + const detail::VpCapabilitiesDesc *pCapsDesc = &pProfileDesc->pRequiredCapabilities[caps_index]; + + for (std::size_t variant_index = 0, variant_count = pCapsDesc->variantCount; variant_index < variant_count; ++variant_index) + { + const detail::VpVariantDesc *variant = &pCapsDesc->pVariants[variant_index]; + + VkBaseOutStructure *base_ptr = reinterpret_cast(pFeatures); + if (variant->feature.pfnFiller != nullptr) + { + while (base_ptr != nullptr) + { + variant->feature.pfnFiller(base_ptr); + base_ptr = base_ptr->pNext; + } + } + } + } + } + + chain->ApplyFeatures(pCreateInfo); + + if (pCreateInfo->flags & VP_DEVICE_CREATE_DISABLE_ROBUST_BUFFER_ACCESS_BIT) + { + pFeatures->features.robustBufferAccess = VK_FALSE; + } + + VkDeviceCreateInfo createInfo{VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO}; + createInfo.pNext = &chain->requiredFeaturesChain; + createInfo.queueCreateInfoCount = pCreateInfo->pCreateInfo->queueCreateInfoCount; + createInfo.pQueueCreateInfos = pCreateInfo->pCreateInfo->pQueueCreateInfos; + createInfo.enabledExtensionCount = static_cast(extensions.size()); + createInfo.ppEnabledExtensionNames = extensions.data(); + + return vp.CreateDevice(physicalDevice, &createInfo, pAllocator, pDevice); } VPAPI_ATTR VkResult vpGetProfileInstanceExtensionProperties( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties) { - return detail::vpGetProfileExtensionProperties( + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t *pPropertyCount, + VkExtensionProperties *pProperties) +{ + return detail::vpGetProfileExtensionProperties( #ifdef VP_USE_OBJECT - capabilities, -#endif//VP_USE_OBJECT - pProfile, pBlockName, detail::EXTENSION_INSTANCE, pPropertyCount, pProperties); + capabilities, +#endif // VP_USE_OBJECT + pProfile, pBlockName, detail::EXTENSION_INSTANCE, pPropertyCount, pProperties); } VPAPI_ATTR VkResult vpGetProfileDeviceExtensionProperties( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties) { - return detail::vpGetProfileExtensionProperties( + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t *pPropertyCount, + VkExtensionProperties *pProperties) +{ + return detail::vpGetProfileExtensionProperties( #ifdef VP_USE_OBJECT - capabilities, -#endif//VP_USE_OBJECT - pProfile, pBlockName, detail::EXTENSION_DEVICE, pPropertyCount, pProperties); + capabilities, +#endif // VP_USE_OBJECT + pProfile, pBlockName, detail::EXTENSION_DEVICE, pPropertyCount, pProperties); } VPAPI_ATTR VkResult vpGetProfileFeatures( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - void* pNext) { + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + void *pNext) +{ #ifdef VP_USE_OBJECT - (void)capabilities; -#endif//VP_USE_OBJECT - - VkResult result = pBlockName == nullptr ? VK_SUCCESS : VK_INCOMPLETE; - - const std::vector& gathered_profiles = detail::GatherProfiles(*pProfile); - - for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) { - const detail::VpProfileDesc* profile_desc = detail::vpGetProfileDesc(gathered_profiles[profile_index].profileName); - if (profile_desc == nullptr) return VK_ERROR_UNKNOWN; - - for (uint32_t capability_index = 0; capability_index < profile_desc->requiredCapabilityCount; ++capability_index) { - const detail::VpCapabilitiesDesc& cap_desc = profile_desc->pRequiredCapabilities[capability_index]; - - for (uint32_t variant_index = 0; variant_index < cap_desc.variantCount; ++variant_index) { - const detail::VpVariantDesc& variant = cap_desc.pVariants[variant_index]; - if (pBlockName != nullptr) { - if (strcmp(variant.blockName, pBlockName) != 0) { - continue; - } - result = VK_SUCCESS; - } - - if (variant.feature.pfnFiller == nullptr) continue; + (void) capabilities; +#endif // VP_USE_OBJECT + + VkResult result = pBlockName == nullptr ? VK_SUCCESS : VK_INCOMPLETE; + + const std::vector &gathered_profiles = detail::GatherProfiles(*pProfile); + + for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) + { + const detail::VpProfileDesc *profile_desc = detail::vpGetProfileDesc(gathered_profiles[profile_index].profileName); + if (profile_desc == nullptr) + return VK_ERROR_UNKNOWN; + + for (uint32_t capability_index = 0; capability_index < profile_desc->requiredCapabilityCount; ++capability_index) + { + const detail::VpCapabilitiesDesc &cap_desc = profile_desc->pRequiredCapabilities[capability_index]; + + for (uint32_t variant_index = 0; variant_index < cap_desc.variantCount; ++variant_index) + { + const detail::VpVariantDesc &variant = cap_desc.pVariants[variant_index]; + if (pBlockName != nullptr) + { + if (strcmp(variant.blockName, pBlockName) != 0) + { + continue; + } + result = VK_SUCCESS; + } + + if (variant.feature.pfnFiller == nullptr) + continue; + + VkBaseOutStructure *p = static_cast(pNext); + while (p != nullptr) + { + variant.feature.pfnFiller(p); + p = p->pNext; + } + } + } + } + + return result; +} - VkBaseOutStructure* p = static_cast(pNext); - while (p != nullptr) { - variant.feature.pfnFiller(p); - p = p->pNext; - } - } - } - } +VPAPI_ATTR VkResult vpGetProfileProperties( +#ifdef VP_USE_OBJECT + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + void *pNext) +{ + VkResult result = pBlockName == nullptr ? VK_SUCCESS : VK_INCOMPLETE; - return result; + VkBool32 multiple_variants = VK_FALSE; + if (vpHasMultipleVariantsProfile( +#ifdef VP_USE_OBJECT + capabilities, +#endif // VP_USE_OBJECT + pProfile, + &multiple_variants) == VK_ERROR_UNKNOWN) + { + return VK_ERROR_UNKNOWN; + } + if (multiple_variants == VK_TRUE && pBlockName == nullptr) + { + return VK_ERROR_UNKNOWN; + } + + const std::vector &gathered_profiles = detail::GatherProfiles(*pProfile); + + for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) + { + const detail::VpProfileDesc *profile_desc = detail::vpGetProfileDesc(gathered_profiles[profile_index].profileName); + if (profile_desc == nullptr) + return VK_ERROR_UNKNOWN; + + for (uint32_t capability_index = 0; capability_index < profile_desc->requiredCapabilityCount; ++capability_index) + { + const detail::VpCapabilitiesDesc &cap_desc = profile_desc->pRequiredCapabilities[capability_index]; + + for (uint32_t variant_index = 0; variant_index < cap_desc.variantCount; ++variant_index) + { + const detail::VpVariantDesc &variant = cap_desc.pVariants[variant_index]; + if (pBlockName != nullptr) + { + if (strcmp(variant.blockName, pBlockName) != 0) + { + continue; + } + result = VK_SUCCESS; + } + + if (variant.property.pfnFiller == nullptr) + continue; + + VkBaseOutStructure *p = static_cast(pNext); + while (p != nullptr) + { + variant.property.pfnFiller(p); + p = p->pNext; + } + } + } + } + + return result; } -VPAPI_ATTR VkResult vpGetProfileProperties( +VPAPI_ATTR VkResult vpGetProfileQueueFamilyProperties( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - void* pNext) { - VkResult result = pBlockName == nullptr ? VK_SUCCESS : VK_INCOMPLETE; - - VkBool32 multiple_variants = VK_FALSE; - if (vpHasMultipleVariantsProfile( + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t *pPropertyCount, + VkQueueFamilyProperties2KHR *pProperties) +{ #ifdef VP_USE_OBJECT - capabilities, -#endif//VP_USE_OBJECT - pProfile, - &multiple_variants) == VK_ERROR_UNKNOWN) { - return VK_ERROR_UNKNOWN; - } - if (multiple_variants == VK_TRUE && pBlockName == nullptr) { - return VK_ERROR_UNKNOWN; - } - - const std::vector& gathered_profiles = detail::GatherProfiles(*pProfile); - - for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) { - const detail::VpProfileDesc* profile_desc = detail::vpGetProfileDesc(gathered_profiles[profile_index].profileName); - if (profile_desc == nullptr) return VK_ERROR_UNKNOWN; - - for (uint32_t capability_index = 0; capability_index < profile_desc->requiredCapabilityCount; ++capability_index) { - const detail::VpCapabilitiesDesc& cap_desc = profile_desc->pRequiredCapabilities[capability_index]; - - for (uint32_t variant_index = 0; variant_index < cap_desc.variantCount; ++variant_index) { - const detail::VpVariantDesc& variant = cap_desc.pVariants[variant_index]; - if (pBlockName != nullptr) { - if (strcmp(variant.blockName, pBlockName) != 0) { - continue; - } - result = VK_SUCCESS; - } - - if (variant.property.pfnFiller == nullptr) continue; - - VkBaseOutStructure* p = static_cast(pNext); - while (p != nullptr) { - variant.property.pfnFiller(p); - p = p->pNext; - } - } - } - } - - return result; + (void) capabilities; +#endif // VP_USE_OBJECT + + if (pPropertyCount == nullptr) + return VK_ERROR_UNKNOWN; + + VkResult result = pBlockName == nullptr ? VK_SUCCESS : VK_INCOMPLETE; + + const std::vector &gathered_profiles = detail::GatherProfiles(*pProfile); + + uint32_t total_queue_family_count = 0; + + for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) + { + const detail::VpProfileDesc *profile_desc = detail::vpGetProfileDesc(gathered_profiles[profile_index].profileName); + if (profile_desc == nullptr) + return VK_ERROR_UNKNOWN; + + for (uint32_t capability_index = 0; capability_index < profile_desc->requiredCapabilityCount; ++capability_index) + { + const detail::VpCapabilitiesDesc &cap_desc = profile_desc->pRequiredCapabilities[capability_index]; + + for (uint32_t variant_index = 0; variant_index < cap_desc.variantCount; ++variant_index) + { + const detail::VpVariantDesc &variant = cap_desc.pVariants[variant_index]; + if (pBlockName != nullptr) + { + if (strcmp(variant.blockName, pBlockName) != 0) + { + continue; + } + result = VK_SUCCESS; + } + + if (pProperties != nullptr) + { + for (uint32_t i = 0; i < variant.queueFamilyCount; ++i) + { + if (total_queue_family_count < *pPropertyCount) + { + if (variant.pQueueFamilies[i].pfnFiller == nullptr) + continue; + + VkBaseOutStructure *p = reinterpret_cast(pProperties); + while (p != nullptr) + { + variant.pQueueFamilies[i].pfnFiller(p); + p = p->pNext; + } + + total_queue_family_count++; + pProperties++; + } + else + { + result = VK_INCOMPLETE; + break; + } + } + } + else + { + total_queue_family_count += variant.queueFamilyCount; + } + } + } + } + + *pPropertyCount = total_queue_family_count; + return result; } VPAPI_ATTR VkResult vpGetProfileFormats( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - uint32_t* pFormatCount, - VkFormat* pFormats) { + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t *pFormatCount, + VkFormat *pFormats) +{ #ifdef VP_USE_OBJECT - (void)capabilities; -#endif//VP_USE_OBJECT - - VkResult result = pBlockName == nullptr ? VK_SUCCESS : VK_INCOMPLETE; - - std::vector results; - - const std::vector& gathered_profiles = detail::GatherProfiles(*pProfile); - - for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) { - const detail::VpProfileDesc* profile_desc = detail::vpGetProfileDesc(gathered_profiles[profile_index].profileName); - if (profile_desc == nullptr) return VK_ERROR_UNKNOWN; - - for (uint32_t capability_index = 0; capability_index < profile_desc->requiredCapabilityCount; ++capability_index) { - const detail::VpCapabilitiesDesc& cap_desc = profile_desc->pRequiredCapabilities[capability_index]; - - for (uint32_t variant_index = 0; variant_index < cap_desc.variantCount; ++variant_index) { - const detail::VpVariantDesc& variant = cap_desc.pVariants[variant_index]; - if (pBlockName != nullptr) { - if (strcmp(variant.blockName, pBlockName) != 0) { - continue; - } - result = VK_SUCCESS; - } - - for (uint32_t format_index = 0; format_index < variant.formatCount; ++format_index) { - if (std::find(results.begin(), results.end(), variant.pFormats[format_index].format) == std::end(results)) { - results.push_back(variant.pFormats[format_index].format); - } - } - } - } - } - - const uint32_t count = static_cast(results.size()); - - if (pFormats == nullptr) { - *pFormatCount = count; - } else { - if (*pFormatCount < count) { - result = VK_INCOMPLETE; - } else { - *pFormatCount = count; - } - - if (*pFormatCount > 0) { - memcpy(pFormats, &results[0], *pFormatCount * sizeof(VkFormat)); - } - } - return result; + (void) capabilities; +#endif // VP_USE_OBJECT + + VkResult result = pBlockName == nullptr ? VK_SUCCESS : VK_INCOMPLETE; + + std::vector results; + + const std::vector &gathered_profiles = detail::GatherProfiles(*pProfile); + + for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) + { + const detail::VpProfileDesc *profile_desc = detail::vpGetProfileDesc(gathered_profiles[profile_index].profileName); + if (profile_desc == nullptr) + return VK_ERROR_UNKNOWN; + + for (uint32_t capability_index = 0; capability_index < profile_desc->requiredCapabilityCount; ++capability_index) + { + const detail::VpCapabilitiesDesc &cap_desc = profile_desc->pRequiredCapabilities[capability_index]; + + for (uint32_t variant_index = 0; variant_index < cap_desc.variantCount; ++variant_index) + { + const detail::VpVariantDesc &variant = cap_desc.pVariants[variant_index]; + if (pBlockName != nullptr) + { + if (strcmp(variant.blockName, pBlockName) != 0) + { + continue; + } + result = VK_SUCCESS; + } + + for (uint32_t format_index = 0; format_index < variant.formatCount; ++format_index) + { + if (std::find(results.begin(), results.end(), variant.pFormats[format_index].format) == std::end(results)) + { + results.push_back(variant.pFormats[format_index].format); + } + } + } + } + } + + const uint32_t count = static_cast(results.size()); + + if (pFormats == nullptr) + { + *pFormatCount = count; + } + else + { + if (*pFormatCount < count) + { + result = VK_INCOMPLETE; + } + else + { + *pFormatCount = count; + } + + if (*pFormatCount > 0) + { + memcpy(pFormats, &results[0], *pFormatCount * sizeof(VkFormat)); + } + } + return result; } VPAPI_ATTR VkResult vpGetProfileFormatProperties( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - VkFormat format, - void* pNext) { + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + VkFormat format, + void *pNext) +{ #ifdef VP_USE_OBJECT - (void)capabilities; -#endif//VP_USE_OBJECT - - VkResult result = pBlockName == nullptr ? VK_SUCCESS : VK_INCOMPLETE; - - const std::vector& gathered_profiles = detail::GatherProfiles(*pProfile); - - for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) { - const char* profile_name = gathered_profiles[profile_index].profileName; - - const detail::VpProfileDesc* pProfileDesc = detail::vpGetProfileDesc(profile_name); - if (pProfileDesc == nullptr) return VK_ERROR_UNKNOWN; - - for (uint32_t required_capability_index = 0; required_capability_index < pProfileDesc->requiredCapabilityCount; - ++required_capability_index) { - const detail::VpCapabilitiesDesc& required_capabilities = pProfileDesc->pRequiredCapabilities[required_capability_index]; - - for (uint32_t required_variant_index = 0; required_variant_index < required_capabilities.variantCount; ++required_variant_index) { - const detail::VpVariantDesc& variant = required_capabilities.pVariants[required_variant_index]; - if (pBlockName != nullptr) { - if (strcmp(variant.blockName, pBlockName) != 0) { - continue; - } - result = VK_SUCCESS; - } - - for (uint32_t format_index = 0; format_index < variant.formatCount; ++format_index) { - if (variant.pFormats[format_index].format != format) { - continue; - } - - VkBaseOutStructure* base_ptr = static_cast(static_cast(pNext)); - while (base_ptr != nullptr) { - variant.pFormats[format_index].pfnFiller(base_ptr); - base_ptr = base_ptr->pNext; - } + (void) capabilities; +#endif // VP_USE_OBJECT + + VkResult result = pBlockName == nullptr ? VK_SUCCESS : VK_INCOMPLETE; + + const std::vector &gathered_profiles = detail::GatherProfiles(*pProfile); + + for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) + { + const char *profile_name = gathered_profiles[profile_index].profileName; + + const detail::VpProfileDesc *pProfileDesc = detail::vpGetProfileDesc(profile_name); + if (pProfileDesc == nullptr) + return VK_ERROR_UNKNOWN; + + for (uint32_t required_capability_index = 0; required_capability_index < pProfileDesc->requiredCapabilityCount; + ++required_capability_index) + { + const detail::VpCapabilitiesDesc &required_capabilities = pProfileDesc->pRequiredCapabilities[required_capability_index]; + + for (uint32_t required_variant_index = 0; required_variant_index < required_capabilities.variantCount; ++required_variant_index) + { + const detail::VpVariantDesc &variant = required_capabilities.pVariants[required_variant_index]; + if (pBlockName != nullptr) + { + if (strcmp(variant.blockName, pBlockName) != 0) + { + continue; + } + result = VK_SUCCESS; + } + + for (uint32_t format_index = 0; format_index < variant.formatCount; ++format_index) + { + if (variant.pFormats[format_index].format != format) + { + continue; + } + + VkBaseOutStructure *base_ptr = static_cast(static_cast(pNext)); + while (base_ptr != nullptr) + { + variant.pFormats[format_index].pfnFiller(base_ptr); + base_ptr = base_ptr->pNext; + } #if defined(VK_VERSION_1_3) || defined(VK_KHR_format_feature_flags2) - VkFormatProperties2KHR* fp2 = static_cast( - detail::vpGetStructure(pNext, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR)); - VkFormatProperties3KHR* fp3 = static_cast( - detail::vpGetStructure(pNext, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR)); - if (fp3 != nullptr) { - VkFormatProperties2KHR fp{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR }; - variant.pFormats[format_index].pfnFiller(static_cast(static_cast(&fp))); - fp3->linearTilingFeatures |= static_cast(fp3->linearTilingFeatures | fp.formatProperties.linearTilingFeatures); - fp3->optimalTilingFeatures |= static_cast(fp3->optimalTilingFeatures | fp.formatProperties.optimalTilingFeatures); - fp3->bufferFeatures |= static_cast(fp3->bufferFeatures | fp.formatProperties.bufferFeatures); - } - if (fp2 != nullptr) { - VkFormatProperties3KHR fp{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR }; - variant.pFormats[format_index].pfnFiller(static_cast(static_cast(&fp))); - fp2->formatProperties.linearTilingFeatures |= static_cast(fp2->formatProperties.linearTilingFeatures | fp.linearTilingFeatures); - fp2->formatProperties.optimalTilingFeatures |= static_cast(fp2->formatProperties.optimalTilingFeatures | fp.optimalTilingFeatures); - fp2->formatProperties.bufferFeatures |= static_cast(fp2->formatProperties.bufferFeatures | fp.bufferFeatures); - } + VkFormatProperties2KHR *fp2 = static_cast( + detail::vpGetStructure(pNext, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR)); + VkFormatProperties3KHR *fp3 = static_cast( + detail::vpGetStructure(pNext, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR)); + if (fp3 != nullptr) + { + VkFormatProperties2KHR fp{VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR}; + variant.pFormats[format_index].pfnFiller(static_cast(static_cast(&fp))); + fp3->linearTilingFeatures |= static_cast(fp3->linearTilingFeatures | fp.formatProperties.linearTilingFeatures); + fp3->optimalTilingFeatures |= static_cast(fp3->optimalTilingFeatures | fp.formatProperties.optimalTilingFeatures); + fp3->bufferFeatures |= static_cast(fp3->bufferFeatures | fp.formatProperties.bufferFeatures); + } + if (fp2 != nullptr) + { + VkFormatProperties3KHR fp{VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR}; + variant.pFormats[format_index].pfnFiller(static_cast(static_cast(&fp))); + fp2->formatProperties.linearTilingFeatures |= static_cast(fp2->formatProperties.linearTilingFeatures | fp.linearTilingFeatures); + fp2->formatProperties.optimalTilingFeatures |= static_cast(fp2->formatProperties.optimalTilingFeatures | fp.optimalTilingFeatures); + fp2->formatProperties.bufferFeatures |= static_cast(fp2->formatProperties.bufferFeatures | fp.bufferFeatures); + } #endif - } - } - } - } + } + } + } + } - return result; + return result; } VPAPI_ATTR VkResult vpGetProfileFeatureStructureTypes( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - uint32_t* pStructureTypeCount, - VkStructureType* pStructureTypes) { - return detail::vpGetProfileStructureTypes( + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t *pStructureTypeCount, + VkStructureType *pStructureTypes) +{ + return detail::vpGetProfileStructureTypes( #ifdef VP_USE_OBJECT - capabilities, -#endif//VP_USE_OBJECT - pProfile, pBlockName, detail::STRUCTURE_FEATURE, pStructureTypeCount, pStructureTypes); + capabilities, +#endif // VP_USE_OBJECT + pProfile, pBlockName, detail::STRUCTURE_FEATURE, pStructureTypeCount, pStructureTypes); } VPAPI_ATTR VkResult vpGetProfilePropertyStructureTypes( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - uint32_t* pStructureTypeCount, - VkStructureType* pStructureTypes) { - return detail::vpGetProfileStructureTypes( + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t *pStructureTypeCount, + VkStructureType *pStructureTypes) +{ + return detail::vpGetProfileStructureTypes( +#ifdef VP_USE_OBJECT + capabilities, +#endif // VP_USE_OBJECT + pProfile, pBlockName, detail::STRUCTURE_PROPERTY, pStructureTypeCount, pStructureTypes); +} + +VPAPI_ATTR VkResult vpGetProfileQueueFamilyStructureTypes( +#ifdef VP_USE_OBJECT + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t *pStructureTypeCount, + VkStructureType *pStructureTypes) +{ + return detail::vpGetProfileStructureTypes( #ifdef VP_USE_OBJECT - capabilities, -#endif//VP_USE_OBJECT - pProfile, pBlockName, detail::STRUCTURE_PROPERTY, pStructureTypeCount, pStructureTypes); + capabilities, +#endif // VP_USE_OBJECT + pProfile, pBlockName, detail::STRUCTURE_QUEUE_FAMILY, pStructureTypeCount, pStructureTypes); } VPAPI_ATTR VkResult vpGetProfileFormatStructureTypes( #ifdef VP_USE_OBJECT - VpCapabilities capabilities, -#endif//VP_USE_OBJECT - const VpProfileProperties* pProfile, - const char* pBlockName, - uint32_t* pStructureTypeCount, - VkStructureType* pStructureTypes) { - return detail::vpGetProfileStructureTypes( + VpCapabilities capabilities, +#endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t *pStructureTypeCount, + VkStructureType *pStructureTypes) +{ + return detail::vpGetProfileStructureTypes( #ifdef VP_USE_OBJECT - capabilities, -#endif//VP_USE_OBJECT - pProfile, pBlockName, detail::STRUCTURE_FORMAT, pStructureTypeCount, pStructureTypes); + capabilities, +#endif // VP_USE_OBJECT + pProfile, pBlockName, detail::STRUCTURE_FORMAT, pStructureTypeCount, pStructureTypes); +} + +#ifdef VK_KHR_video_queue +// Query the list of video profiles specified by the profile +VPAPI_ATTR VkResult vpGetProfileVideoProfiles( +# ifdef VP_USE_OBJECT + VpCapabilities capabilities, +# endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t *pVideoProfileCount, + VpVideoProfileProperties *pVideoProfiles) +{ +# ifdef VP_USE_OBJECT + (void) capabilities; +# endif // VP_USE_OBJECT + if (pVideoProfileCount == nullptr) + return VK_ERROR_UNKNOWN; + + VkResult result = pBlockName == nullptr ? VK_SUCCESS : VK_INCOMPLETE; + + uint32_t total_video_profile_count = 0; + + const std::vector &gathered_profiles = detail::GatherProfiles(*pProfile); + + for (std::size_t profile_index = 0, profile_count = gathered_profiles.size(); profile_index < profile_count; ++profile_index) + { + const detail::VpProfileDesc *profile_desc = detail::vpGetProfileDesc(gathered_profiles[profile_index].profileName); + if (profile_desc == nullptr) + return VK_ERROR_UNKNOWN; + + for (uint32_t capability_index = 0; capability_index < profile_desc->requiredCapabilityCount; ++capability_index) + { + const detail::VpCapabilitiesDesc &cap_desc = profile_desc->pRequiredCapabilities[capability_index]; + + for (uint32_t variant_index = 0; variant_index < cap_desc.variantCount; ++variant_index) + { + const detail::VpVariantDesc &variant = cap_desc.pVariants[variant_index]; + if (pBlockName != nullptr) + { + if (strcmp(variant.blockName, pBlockName) != 0) + { + continue; + } + result = VK_SUCCESS; + } + + if (pVideoProfiles != nullptr) + { + for (uint32_t i = 0; i < variant.videoProfileCount; ++i) + { + if (total_video_profile_count < *pVideoProfileCount) + { + *pVideoProfiles = variant.pVideoProfiles[i].properties; + total_video_profile_count++; + pVideoProfiles++; + } + else + { + result = VK_INCOMPLETE; + break; + } + } + } + else + { + total_video_profile_count += variant.videoProfileCount; + } + } + } + } + + *pVideoProfileCount = total_video_profile_count; + return result; +} + +VPAPI_ATTR VkResult vpGetProfileVideoProfileInfo( +# ifdef VP_USE_OBJECT + VpCapabilities capabilities, +# endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t videoProfileIndex, + VkVideoProfileInfoKHR *pVideoProfileInfo) +{ +# ifdef VP_USE_OBJECT + (void) capabilities; +# endif // VP_USE_OBJECT + + const detail::VpVideoProfileDesc *pVideoProfileDesc = nullptr; + VkResult result = detail::vpGetProfileVideoProfileDesc(pProfile, pBlockName, videoProfileIndex, &pVideoProfileDesc); + + if (pVideoProfileDesc != nullptr) + { + VkBaseOutStructure *p = reinterpret_cast(pVideoProfileInfo); + while (p != nullptr) + { + pVideoProfileDesc->info.pfnFiller(p); + p = p->pNext; + } + } + + return result; +} + +VPAPI_ATTR VkResult vpGetProfileVideoCapabilities( +# ifdef VP_USE_OBJECT + VpCapabilities capabilities, +# endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t videoProfileIndex, + void *pNext) +{ +# ifdef VP_USE_OBJECT + (void) capabilities; +# endif // VP_USE_OBJECT + + const detail::VpVideoProfileDesc *pVideoProfileDesc = nullptr; + VkResult result = detail::vpGetProfileVideoProfileDesc(pProfile, pBlockName, videoProfileIndex, &pVideoProfileDesc); + + if (pVideoProfileDesc != nullptr) + { + VkBaseOutStructure *p = reinterpret_cast(pNext); + while (p != nullptr) + { + pVideoProfileDesc->capability.pfnFiller(p); + p = p->pNext; + } + } + + return result; +} + +VPAPI_ATTR VkResult vpGetProfileVideoFormatProperties( +# ifdef VP_USE_OBJECT + VpCapabilities capabilities, +# endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t videoProfileIndex, + uint32_t *pPropertyCount, + VkVideoFormatPropertiesKHR *pProperties) +{ +# ifdef VP_USE_OBJECT + (void) capabilities; +# endif // VP_USE_OBJECT + + const detail::VpVideoProfileDesc *pVideoProfileDesc = nullptr; + VkResult result = detail::vpGetProfileVideoProfileDesc(pProfile, pBlockName, videoProfileIndex, &pVideoProfileDesc); + + uint32_t property_count = 0; + if (pVideoProfileDesc != nullptr) + { + if (pProperties != nullptr) + { + for (; property_count < pVideoProfileDesc->formatCount; ++property_count) + { + if (property_count < *pPropertyCount) + { + VkBaseOutStructure *p = reinterpret_cast(&pProperties[property_count]); + while (p != nullptr) + { + pVideoProfileDesc->pFormats[property_count].pfnFiller(p); + p = p->pNext; + } + } + else + { + result = VK_INCOMPLETE; + break; + } + } + } + else + { + property_count = pVideoProfileDesc->formatCount; + } + } + + *pPropertyCount = property_count; + return result; +} + +VPAPI_ATTR VkResult vpGetProfileVideoProfileInfoStructureTypes( +# ifdef VP_USE_OBJECT + VpCapabilities capabilities, +# endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t videoProfileIndex, + uint32_t *pStructureTypeCount, + VkStructureType *pStructureTypes) +{ +# ifdef VP_USE_OBJECT + (void) capabilities; +# endif // VP_USE_OBJECT + + const detail::VpVideoProfileDesc *pVideoProfileDesc = nullptr; + VkResult result = detail::vpGetProfileVideoProfileDesc(pProfile, pBlockName, videoProfileIndex, &pVideoProfileDesc); + + if (pVideoProfileDesc != nullptr) + { + if (pStructureTypes != nullptr) + { + if (*pStructureTypeCount < pVideoProfileDesc->infoStructTypeCount) + { + result = VK_INCOMPLETE; + } + else + { + *pStructureTypeCount = pVideoProfileDesc->infoStructTypeCount; + } + if (*pStructureTypeCount > 0) + { + memcpy(pStructureTypes, pVideoProfileDesc->pInfoStructTypes, *pStructureTypeCount * sizeof(VkStructureType)); + } + } + else + { + *pStructureTypeCount = pVideoProfileDesc->infoStructTypeCount; + } + } + + return result; +} + +VPAPI_ATTR VkResult vpGetProfileVideoCapabilityStructureTypes( +# ifdef VP_USE_OBJECT + VpCapabilities capabilities, +# endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t videoProfileIndex, + uint32_t *pStructureTypeCount, + VkStructureType *pStructureTypes) +{ +# ifdef VP_USE_OBJECT + (void) capabilities; +# endif // VP_USE_OBJECT + + const detail::VpVideoProfileDesc *pVideoProfileDesc = nullptr; + VkResult result = detail::vpGetProfileVideoProfileDesc(pProfile, pBlockName, videoProfileIndex, &pVideoProfileDesc); + + if (pVideoProfileDesc != nullptr) + { + if (pStructureTypes != nullptr) + { + if (*pStructureTypeCount < pVideoProfileDesc->capabilityStructTypeCount) + { + result = VK_INCOMPLETE; + } + else + { + *pStructureTypeCount = pVideoProfileDesc->capabilityStructTypeCount; + } + if (*pStructureTypeCount > 0) + { + memcpy(pStructureTypes, pVideoProfileDesc->pCapabilityStructTypes, *pStructureTypeCount * sizeof(VkStructureType)); + } + } + else + { + *pStructureTypeCount = pVideoProfileDesc->capabilityStructTypeCount; + } + } + + return result; +} + +VPAPI_ATTR VkResult vpGetProfileVideoFormatStructureTypes( +# ifdef VP_USE_OBJECT + VpCapabilities capabilities, +# endif // VP_USE_OBJECT + const VpProfileProperties *pProfile, + const char *pBlockName, + uint32_t videoProfileIndex, + uint32_t *pStructureTypeCount, + VkStructureType *pStructureTypes) +{ +# ifdef VP_USE_OBJECT + (void) capabilities; +# endif // VP_USE_OBJECT + + const detail::VpVideoProfileDesc *pVideoProfileDesc = nullptr; + VkResult result = detail::vpGetProfileVideoProfileDesc(pProfile, pBlockName, videoProfileIndex, &pVideoProfileDesc); + + if (pVideoProfileDesc != nullptr) + { + if (pStructureTypes != nullptr) + { + if (*pStructureTypeCount < pVideoProfileDesc->formatStructTypeCount) + { + result = VK_INCOMPLETE; + } + else + { + *pStructureTypeCount = pVideoProfileDesc->formatStructTypeCount; + } + if (*pStructureTypeCount > 0) + { + memcpy(pStructureTypes, pVideoProfileDesc->pFormatStructTypes, *pStructureTypeCount * sizeof(VkStructureType)); + } + } + else + { + *pStructureTypeCount = pVideoProfileDesc->formatStructTypeCount; + } + } + + return result; } +#endif // VK_KHR_video_queue diff --git a/shaders/tensor_and_data_graph/glsl/blit.frag b/shaders/tensor_and_data_graph/glsl/blit.frag new file mode 100644 index 000000000..971796a09 --- /dev/null +++ b/shaders/tensor_and_data_graph/glsl/blit.frag @@ -0,0 +1,32 @@ +#version 460 + +/* Copyright (c) 2024-2025, Arm Limited and Contributors + * + * SPDX-License-Identifier: Apache-2.0 + * + * 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. + */ + +// Simple blitting fragment shader. Output is sampled from a texture using UVs that are passed from the vertex shader + +layout(location = 0) in vec2 in_uv; + +layout(set = 0, binding = 0) uniform sampler2D in_texture; + +layout(location = 0) out vec4 out_color; + +void main() +{ + out_color = texture(in_texture, in_uv); +} + diff --git a/shaders/tensor_and_data_graph/glsl/blit.frag.spv b/shaders/tensor_and_data_graph/glsl/blit.frag.spv new file mode 100644 index 000000000..345dd5e45 Binary files /dev/null and b/shaders/tensor_and_data_graph/glsl/blit.frag.spv differ diff --git a/shaders/tensor_and_data_graph/glsl/fullscreen.vert b/shaders/tensor_and_data_graph/glsl/fullscreen.vert new file mode 100644 index 000000000..3d9507eb8 --- /dev/null +++ b/shaders/tensor_and_data_graph/glsl/fullscreen.vert @@ -0,0 +1,36 @@ +#version 460 + +/* Copyright (c) 2024-2025, Arm Limited and Contributors + * + * SPDX-License-Identifier: Apache-2.0 + * + * 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. + */ + +// Simple fullscreen triangle procedural vertex shader. UVs are also output for consumption by the blit.frag fragment shader. + +layout (location = 0) out vec2 out_uv; + +void main() +{ + vec2 vertices[] = + { + vec2(-1.0f, 3.0f), + vec2(-1.0f, -1.0f), + vec2( 3.0f, -1.0f), + }; + vec2 vertex = vertices[gl_VertexIndex % 3].xy; + gl_Position = vec4(vertex, 0.0f, 1.0f); + out_uv = (vertex + 1.0) / 2.0f; +} + diff --git a/shaders/tensor_and_data_graph/glsl/fullscreen.vert.spv b/shaders/tensor_and_data_graph/glsl/fullscreen.vert.spv new file mode 100644 index 000000000..c0c251629 Binary files /dev/null and b/shaders/tensor_and_data_graph/glsl/fullscreen.vert.spv differ diff --git a/shaders/tensor_and_data_graph/glsl/visualization_two_tensors.comp b/shaders/tensor_and_data_graph/glsl/visualization_two_tensors.comp new file mode 100644 index 000000000..0274ad59b --- /dev/null +++ b/shaders/tensor_and_data_graph/glsl/visualization_two_tensors.comp @@ -0,0 +1,95 @@ +#version 460 + +/* Copyright (c) 2024-2025, Arm Limited and Contributors + * + * SPDX-License-Identifier: Apache-2.0 + * + * 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. + */ + +// Compute shader which reads from two tensors representing RGB images (input_tensor and output_tensor) +// and draws them to an output image. + +// Enable the extension that allows us to read from Tensors. +#extension GL_ARM_tensors : enable + +// Our two input tensors, each being a 4-dimensional array of floats +layout (set = 0, binding = 0) uniform tensorARM input_tensor; +layout (set = 0, binding = 1) uniform tensorARM output_tensor; + +// Output image to write to +layout(rgba8, set = 0, binding = 2) writeonly uniform image2D output_image; + +// Push constants to provide the size of the output image, so that we can position things correctly +layout(push_constant) uniform push_constants +{ + ivec2 output_image_size; +}; + +// If the given pixel_coord is within the rectangle described by (left,top,width, height), then updates +// `color` with data from the `input_tensor` at an interpolated location based on the position in the rectangle. +void draw_input_tensor(inout vec4 color, ivec2 pixel_coord, int left, int top, int width, int height) +{ + if (pixel_coord.x >= left && pixel_coord.x < left + width && pixel_coord.y >= top && pixel_coord.y < top + height) + { + // Query the size of the tensor, in dimensions 2 (width) and 1 (height) + uint tensor_width = tensorSizeARM(input_tensor, 2); + uint tensor_height = tensorSizeARM(input_tensor, 1); + // Work out the location in the tensor to read from + uint[4] tensor_coords = { 0, + uint(float(pixel_coord.y - top) / height * tensor_height), + uint(float(pixel_coord.x - left) / width * tensor_width), + 0 }; + // Read three values from the tensor, starting from this location and moving along the least-significant dimension. + // This gives us the red, green and blue values. + float[3] value; + tensorReadARM(input_tensor, tensor_coords, value); + color = vec4(value[0], value[1], value[2], 1.0f); + } +} + +// As above, but reads from the output_tensor. +void draw_output_tensor(inout vec4 color, ivec2 pixel_coord, int left, int top, int width, int height) +{ + if (pixel_coord.x >= left && pixel_coord.x < left + width && pixel_coord.y >= top && pixel_coord.y < top + height) + { + uint tensor_width = tensorSizeARM(output_tensor, 2); + uint tensor_height = tensorSizeARM(output_tensor, 1); + uint[4] tensor_coords = { 0, + uint(float(pixel_coord.y - top) / height * tensor_height), + uint(float(pixel_coord.x - left) / width * tensor_width), + 0 }; + float[3] value; + tensorReadARM(output_tensor, tensor_coords, value); + color = vec4(value[0], value[1], value[2], 1.0f); + } +} + + +layout(local_size_x = 8, local_size_y = 8) in; +void main() +{ + ivec2 pixel_coord = ivec2(gl_GlobalInvocationID.xy); + if (pixel_coord.x >= output_image_size.x || pixel_coord.y >= output_image_size.y) + { + return; // Out-of-bounds + } + + vec4 out_color = vec4(0.0f, 0.0f, 0.0f, 1.0f); + + // Position the input_tensor to the left of the middle, and the output_tensor to the right of the middle + draw_input_tensor(out_color, pixel_coord, output_image_size.x / 2 - 300, output_image_size.y / 2 - 100, 200, 200); + draw_output_tensor(out_color, pixel_coord, output_image_size.x / 2 + 100, output_image_size.y / 2 - 100, 200, 200); + + imageStore(output_image, ivec2(pixel_coord), out_color); +} diff --git a/shaders/tensor_and_data_graph/glsl/visualization_two_tensors.comp.spv b/shaders/tensor_and_data_graph/glsl/visualization_two_tensors.comp.spv new file mode 100644 index 000000000..4ff8ebb51 Binary files /dev/null and b/shaders/tensor_and_data_graph/glsl/visualization_two_tensors.comp.spv differ diff --git a/shaders/tensor_and_data_graph/simple_tensor_and_data_graph/spirv/pooling.spvasm b/shaders/tensor_and_data_graph/simple_tensor_and_data_graph/spirv/pooling.spvasm new file mode 100644 index 000000000..c7c912454 --- /dev/null +++ b/shaders/tensor_and_data_graph/simple_tensor_and_data_graph/spirv/pooling.spvasm @@ -0,0 +1,86 @@ +; Copyright (c) 2024-2025, Arm Limited and Contributors +; +; SPDX-License-Identifier: Apache-2.0 +; +; 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. +; + +; A simple neural network with a single pooling layer, expressed in SPIR-V assembly. +; See simple_tensor_and_data_graph/README.adoc for a more detailed explanation of this code. + + ; Boilerplate + OpCapability Shader + OpCapability TensorsARM + OpCapability GraphARM + OpExtension "SPV_ARM_tensors" + OpExtension "SPV_ARM_graph" + + ; Import TOSA instructions for neural network operations + %tosa = OpExtInstImport "TOSA.001000.1" + + ; More boilerplate + OpMemoryModel Logical GLSL450 + + ; Descriptor set interface + OpDecorate %input_tensor_ptr DescriptorSet 0 + OpDecorate %input_tensor_ptr Binding 0 + OpDecorate %output_tensor_ptr DescriptorSet 0 + OpDecorate %output_tensor_ptr Binding 1 + + ; Types and constants + %uint = OpTypeInt 32 0 + %float = OpTypeFloat 32 + %uint_0 = OpConstant %uint 0 + %uint_1 = OpConstant %uint 1 + %uint_2 = OpConstant %uint 2 + %uint_3 = OpConstant %uint 3 + %uint_4 = OpConstant %uint 4 + %input_width = OpConstant %uint 10 + %input_height = OpConstant %uint 10 + %output_width = OpConstant %uint 5 + %output_height = OpConstant %uint 5 + %float_0 = OpConstant %float 0 + %uint_array_l1 = OpTypeArray %uint %uint_1 + %uint_array_l4 = OpTypeArray %uint %uint_4 + %uint_array_l1_1 = OpConstantComposite %uint_array_l1 %uint_1 + %uint_array_l1_2 = OpConstantComposite %uint_array_l1 %uint_2 + %uint_array_l1_4 = OpConstantComposite %uint_array_l1 %uint_4 + %uint_array_l4_1_ih_iw_3 = OpConstantComposite %uint_array_l4 %uint_1 %input_height %input_width %uint_3 + %uint_array_l4_1_oh_ow_3 = OpConstantComposite %uint_array_l4 %uint_1 %output_height %output_width %uint_3 + %float_tensor_r1_s1 = OpTypeTensorARM %float %uint_1 %uint_array_l1_1 + %uint_tensor_r1_s2 = OpTypeTensorARM %uint %uint_1 %uint_array_l1_2 + %uint_tensor_r1_s4 = OpTypeTensorARM %uint %uint_1 %uint_array_l1_4 + %float_tensor_r4_s_1_ih_iw_3 = OpTypeTensorARM %float %uint_4 %uint_array_l4_1_ih_iw_3 + %float_tensor_r4_s_1_oh_ow_3 = OpTypeTensorARM %float %uint_4 %uint_array_l4_1_oh_ow_3 +%ptr_float_tensor_r4_s_1_ih_iw_3 = OpTypePointer UniformConstant %float_tensor_r4_s_1_ih_iw_3 +%ptr_float_tensor_r4_s_1_oh_ow_3 = OpTypePointer UniformConstant %float_tensor_r4_s_1_oh_ow_3 + + ; Parameters for pooling layer + %avg_pool_kernel = OpConstantComposite %uint_tensor_r1_s2 %uint_3 %uint_3 + %avg_pool_stride = OpConstantComposite %uint_tensor_r1_s2 %uint_2 %uint_2 + %avg_pool_pad = OpConstantComposite %uint_tensor_r1_s4 %uint_0 %uint_0 %uint_0 %uint_0 + %avg_pool_input_zero_point = OpConstantComposite %float_tensor_r1_s1 %float_0 + %avg_pool_output_zero_point = OpConstantComposite %float_tensor_r1_s1 %float_0 + + ; Graph type and interface variables + %graph_type = OpTypeGraphARM 1 %float_tensor_r4_s_1_ih_iw_3 %float_tensor_r4_s_1_oh_ow_3 + %input_tensor_ptr = OpVariable %ptr_float_tensor_r4_s_1_ih_iw_3 UniformConstant + %output_tensor_ptr = OpVariable %ptr_float_tensor_r4_s_1_oh_ow_3 UniformConstant + + ; Neural network layers defined as a graph + OpGraphEntryPointARM %graph "main" %input_tensor_ptr %output_tensor_ptr + %graph = OpGraphARM %graph_type + %in = OpGraphInputARM %float_tensor_r4_s_1_ih_iw_3 %uint_0 + %out = OpExtInst %float_tensor_r4_s_1_oh_ow_3 %tosa AVG_POOL2D %avg_pool_kernel %avg_pool_stride %avg_pool_pad %uint_2 %in %avg_pool_input_zero_point %avg_pool_output_zero_point + OpGraphSetOutputARM %out %uint_0 + OpGraphEndARM diff --git a/shaders/tensor_and_data_graph/simple_tensor_and_data_graph/spirv/pooling.spvasm.spv b/shaders/tensor_and_data_graph/simple_tensor_and_data_graph/spirv/pooling.spvasm.spv new file mode 100644 index 000000000..9e01041da Binary files /dev/null and b/shaders/tensor_and_data_graph/simple_tensor_and_data_graph/spirv/pooling.spvasm.spv differ diff --git a/shaders/tensor_and_data_graph/spirv/conv2d.spvasm b/shaders/tensor_and_data_graph/spirv/conv2d.spvasm new file mode 100644 index 000000000..f1adb0c53 --- /dev/null +++ b/shaders/tensor_and_data_graph/spirv/conv2d.spvasm @@ -0,0 +1,89 @@ +; Copyright (c) 2025, Arm Limited and Contributors +; +; SPDX-License-Identifier: Apache-2.0 +; +; 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. +; + +; A simple neural network with a single conv2d layer, expressed in SPIR-V assembly. + + ; Boilerplate + OpCapability Shader + OpCapability TensorsARM + OpCapability GraphARM + OpExtension "SPV_ARM_tensors" + OpExtension "SPV_ARM_graph" + + ; Import TOSA instructions for neural network operations + %tosa = OpExtInstImport "TOSA.001000.1" + + ; More boilerplate + OpMemoryModel Logical GLSL450 + + ; Descriptor set interface + OpDecorate %input_tensor_ptr DescriptorSet 0 + OpDecorate %input_tensor_ptr Binding 0 + OpDecorate %output_tensor_ptr DescriptorSet 0 + OpDecorate %output_tensor_ptr Binding 1 + + ; Types and constants + %bool = OpTypeBool + %false = OpConstantFalse %bool + %uint = OpTypeInt 32 0 + %uint_0 = OpConstant %uint 0 + %uint_1 = OpConstant %uint 1 + %uint_2 = OpConstant %uint 2 + %uint_3 = OpConstant %uint 3 + %uint_4 = OpConstant %uint 4 + %width = OpConstant %uint 20 + %height = OpConstant %uint 20 + %float = OpTypeFloat 32 + %float_0 = OpConstant %float 0 + %uint_array_l1 = OpTypeArray %uint %uint_1 + %uint_array_l4 = OpTypeArray %uint %uint_4 + %uint_array_l1_1 = OpConstantComposite %uint_array_l1 %uint_1 + %uint_array_l1_2 = OpConstantComposite %uint_array_l1 %uint_2 + %uint_array_l1_3 = OpConstantComposite %uint_array_l1 %uint_3 + %uint_array_l1_4 = OpConstantComposite %uint_array_l1 %uint_4 + %uint_array_l4_3_3_3_3 = OpConstantComposite %uint_array_l4 %uint_3 %uint_3 %uint_3 %uint_3 + %uint_array_l4_1_h_w_3 = OpConstantComposite %uint_array_l4 %uint_1 %height %width %uint_3 + %float_tensor_r1_s1 = OpTypeTensorARM %float %uint_1 %uint_array_l1_1 + %uint_tensor_r1_s2 = OpTypeTensorARM %uint %uint_1 %uint_array_l1_2 + %float_tensor_r1_s3 = OpTypeTensorARM %float %uint_1 %uint_array_l1_3 + %uint_tensor_r1_s4 = OpTypeTensorARM %uint %uint_1 %uint_array_l1_4 + %float_tensor_r4_s_3_3_3_3 = OpTypeTensorARM %float %uint_4 %uint_array_l4_3_3_3_3 + %float_tensor_r4_s_1_h_w_3 = OpTypeTensorARM %float %uint_4 %uint_array_l4_1_h_w_3 +%ptr_float_tensor_r4_s_1_h_w_3 = OpTypePointer UniformConstant %float_tensor_r4_s_1_h_w_3 + + ; Parameters for conv2d layer + %conv_pad = OpConstantComposite %uint_tensor_r1_s4 %uint_1 %uint_1 %uint_1 %uint_1 + %conv_stride = OpConstantComposite %uint_tensor_r1_s2 %uint_1 %uint_1 + %conv_dilation = OpConstantComposite %uint_tensor_r1_s2 %uint_1 %uint_1 + %conv_input_zero_point = OpConstantComposite %float_tensor_r1_s1 %float_0 + %conv_weight_zero_point = OpConstantComposite %float_tensor_r1_s1 %float_0 + + %conv_weights = OpGraphConstantARM %float_tensor_r4_s_3_3_3_3 0 + %conv_biases = OpGraphConstantARM %float_tensor_r1_s3 1 + + ; Graph type and interface variables + %graph_type = OpTypeGraphARM 1 %float_tensor_r4_s_1_h_w_3 %float_tensor_r4_s_1_h_w_3 + %input_tensor_ptr = OpVariable %ptr_float_tensor_r4_s_1_h_w_3 UniformConstant + %output_tensor_ptr = OpVariable %ptr_float_tensor_r4_s_1_h_w_3 UniformConstant + + ; Neural network layers defined as a graph + OpGraphEntryPointARM %graph "main" %input_tensor_ptr %output_tensor_ptr + %graph = OpGraphARM %graph_type + %in = OpGraphInputARM %float_tensor_r4_s_1_h_w_3 %uint_0 + %out = OpExtInst %float_tensor_r4_s_1_h_w_3 %tosa CONV2D %conv_pad %conv_stride %conv_dilation %uint_2 %false %in %conv_weights %conv_biases %conv_input_zero_point %conv_weight_zero_point + OpGraphSetOutputARM %out %uint_0 + OpGraphEndARM \ No newline at end of file diff --git a/shaders/tensor_and_data_graph/spirv/conv2d.spvasm.spv b/shaders/tensor_and_data_graph/spirv/conv2d.spvasm.spv new file mode 100644 index 000000000..e38cff343 Binary files /dev/null and b/shaders/tensor_and_data_graph/spirv/conv2d.spvasm.spv differ diff --git a/third_party/spirv-cross b/third_party/spirv-cross index 9daa7fe0a..d8e3e2b14 160000 --- a/third_party/spirv-cross +++ b/third_party/spirv-cross @@ -1 +1 @@ -Subproject commit 9daa7fe0a36dbe5c5b810d74d2cc43b202407d57 +Subproject commit d8e3e2b141b8c8a167b2e3984736a6baacff316c diff --git a/third_party/volk b/third_party/volk index 01986ac85..a8da8ef33 160000 --- a/third_party/volk +++ b/third_party/volk @@ -1 +1 @@ -Subproject commit 01986ac85fa2e5c70df09aeae9c907e27c5d50b2 +Subproject commit a8da8ef3368482b0ee9b0ec0c6079a16a89c6924 diff --git a/third_party/vulkan b/third_party/vulkan index d4a196d8c..2cd90f9d2 160000 --- a/third_party/vulkan +++ b/third_party/vulkan @@ -1 +1 @@ -Subproject commit d4a196d8c84e032d27f999adcea3075517c1c97f +Subproject commit 2cd90f9d20df57eac214c148f3aed885372ddcfe